/*

**  File:       TextFile.c

**

**  Contains:   Text file support for simple text application.

**

**  Version:    SimpleText 1.4 or later

**

** Copyright 1993-1999 Apple Computer. All rights reserved.

**

**  You may incorporate this sample code into your applications without

**  restriction, though the sample code has been provided "AS IS" and the

**  responsibility for its operation is 100% yours.  However, what you are

**  not permitted to do is to redistribute the source as "DSC Sample Code"

**  after having made changes. If you're going to re-distribute the source,

**  we require that you make it clear in the source that the code was

**  descended from Apple Sample Code, but that you've made changes.

*/

#include "MacIncludes.h"

#include "TextFile.h"

#pragma segment Text

// --------------------------------------------------------------------------------------------------------------

// INTERNAL DEFINES

// --------------------------------------------------------------------------------------------------------------

#define kOnePageWidth       600         // preferred width of a window

#define kMargins            4           // margins in window

#define kPrintMargins       8           // margins in printing window

#define kGXPrintMargins     10          // margins in printing a GX window

#define kPictureBase        1000        // resource base ID for PICTs in documents

#define kSoundBase          10000       // resource base ID for 'snd 's in documents

// resources for controling printing

#define kFormResource       'form'

    #define kFormFeed           0x00000001  // form feed after this line

#define kContentsListID     10000       // resource ID for STR# contents menu       

// some memory requirements

#define kPrefBufferSize     90*1024

#define kMinBufferSize      5*1024

#define kDeleteKey          8

#define kForwardDeleteKey   0x75

extern pascal void AsmClikLoop();

#define ABS(n)              (((n) < 0) ? -(n) : (n))

// --------------------------------------------------------------------------------------------------------------

// GLOBALS USED ONLY BY THESE ROUTINES

// --------------------------------------------------------------------------------------------------------------

// These variables are used for speech, notice that on purpose we only

// support a single channel at a time.

static SpeechChannel    gSpeechChannel = nil;       

static VoiceSpec        gCurrentVoice;

static Ptr              gSpeakPtr = nil;

static Boolean          gAddedVoices = false;

static Str31            gPictMarker1, gPictMarker2;

// --------------------------------------------------------------------------------------------------------------

// EXTERNAL FUNCTIONS

// --------------------------------------------------------------------------------------------------------------

extern OSErr    TextDragTracking(WindowRef pWindow, void *pData, DragReference theDragRef, short message);

extern OSErr    TextDragReceive(WindowRef pWindow, void *refCon, DragReference theDragRef);

extern Boolean  DragText(WindowRef pWindow, void *pData, EventRecord *pEvent, RgnHandle hilightRgn);

// --------------------------------------------------------------------------------------------------------------

// INTERNAL ROUTINES

// --------------------------------------------------------------------------------------------------------------

static void TextAddContentsMenu(WindowDataPtr pData);

static void TextRemoveContentsMenu(WindowDataPtr pData);

static OSErr TextGetContentsListItem(WindowDataPtr pData, short itemNum, StringPtr menuStr, StringPtr searchStr, short *totalItems);

static OSErr TextAdjustContentsMenu(WindowDataPtr pData);

// --------------------------------------------------------------------------------------------------------------

// UNDO UTILITY FUNCTIONS

// --------------------------------------------------------------------------------------------------------------

OSErr SaveCurrentUndoState(WindowDataPtr pData, short newCommandID)

{

    OSErr       anErr = noErr;

    TEHandle    hTE = ((TextDataPtr) pData)->hTE;

    // this is only a new command if:

    //  the command ID is different

    // OR

    //  the selection is a range, and not equal to the old one

    if  (

            ( ((TextDataPtr) pData)->prevCommandID != newCommandID )

        ||

            (

                ( (**hTE).selStart != (**hTE).selEnd )

            ||

                ( ABS((**hTE).selStart - ((TextDataPtr) pData)->prevSelStart) > 1 )

            )

        )

        {

        Handle      tempHandle;

        Size        tempSize;

        // if we don't have save handles, make em!

        if (!((TextDataPtr) pData)->prevText)

            {

            ((TextDataPtr) pData)->prevText = NewHandle(0);

            anErr = MemError();

            nrequire(anErr, MakeTextSave);

            }

        if  (!((TextDataPtr) pData)->prevStyle) 

            {

            ((TextDataPtr) pData)->prevStyle = NewHandle(0);

            anErr = MemError();

            nrequire(anErr, MakeStyleSave);

            }

        // grow the save handles and block move into them

        tempHandle = (**hTE).hText;

        tempSize = GetHandleSize(tempHandle);

        SetHandleSize( ((TextDataPtr) pData)->prevText, tempSize);

        anErr = MemError();

        nrequire(anErr, GrowTextSave);

        BlockMoveData(*tempHandle, * ((TextDataPtr) pData)->prevText, tempSize );

        tempHandle = (Handle) TEGetStyleHandle(hTE);

        tempSize = GetHandleSize(tempHandle);

        SetHandleSize( ((TextDataPtr) pData)->prevStyle, tempSize);

        anErr = MemError();

        nrequire(anErr, GrowTextSave);

        BlockMoveData(*tempHandle, * ((TextDataPtr) pData)->prevStyle, tempSize );

        // save length

        ((TextDataPtr) pData)->prevLength = (**hTE).teLength;

        ((TextDataPtr) pData)->beforeSelStart = (**hTE).selStart;

        ((TextDataPtr) pData)->beforeSelEnd = (**hTE).selEnd;

        }

    // save start and end of the selection

    ((TextDataPtr) pData)->prevSelStart = (**hTE).selStart;

    // if we didn't have any problems, then we can undo this operation

    ((TextDataPtr) pData)->prevCommandID = newCommandID;

    return(noErr);

// EXCEPTION HANDLING

GrowStyleSave:

GrowTextSave:

MakeStyleSave:

MakeTextSave:

    // can't undo because of an error 

    // (at some point might warn the user, but that's probably more annoying)

    ((TextDataPtr) pData)->prevCommandID = cNull;

    return(anErr);

} // SaveCurrentUndoState

// --------------------------------------------------------------------------------------------------------------

static void PerformUndo(WindowDataPtr pData)

{

    if (((TextDataPtr) pData)->prevCommandID != cNull)

        {

        TEHandle    hTE = ((TextDataPtr) pData)->hTE;

        long        tempLong;

        // undo text

        tempLong = (long) (**hTE).hText;

        (**hTE).hText = ((TextDataPtr) pData)->prevText;

        ((TextDataPtr) pData)->prevText = (Handle)tempLong;

        // undo length

        tempLong = (long) (**hTE).teLength;

        (**hTE).teLength = ((TextDataPtr) pData)->prevLength;

        ((TextDataPtr) pData)->prevLength = tempLong;

        // undo style

        tempLong = (long) TEGetStyleHandle(hTE);

        if (HandToHand((Handle*) &tempLong) == noErr)

            {

            TESetStyleHandle( (TEStyleHandle) ((TextDataPtr) pData)->prevStyle, hTE );

            ((TextDataPtr) pData)->prevStyle = (Handle)tempLong;

            }

        // undo selection

            {

            short   start, end;

            start = ((TextDataPtr) pData)->beforeSelStart;

            end = ((TextDataPtr) pData)->beforeSelEnd;

            ((TextDataPtr) pData)->prevSelStart = (**hTE).selStart;

            TESetSelect(start, end, hTE);

            }

        }

} // PerformUndo

// --------------------------------------------------------------------------------------------------------------

// TEXT EDIT UTILITY FUNCTIONS

// --------------------------------------------------------------------------------------------------------------

static long CalculateTextEditHeight(TEHandle hTE)

{

    long    result;

    short   length;

    result = TEGetHeight(32767, 0, hTE);

    length = (**hTE).teLength;

    // Text Edit doesn't return the height of the last character, if that

    // character is a <cr>.  So if we see that, we go grab the height of

    // that last character and add it into the total height.

    if ( (length) && ( (*(**hTE).hText)[length-1] == '\n') )

        {

        TextStyle   theStyle;

        short       theHeight;

        short       theAscent;

        TEGetStyle(length, &theStyle, &theHeight, &theAscent, hTE);

        result += theHeight;

        }

    return result;

} // CalculateTextEditHeight

// --------------------------------------------------------------------------------------------------------------

void AdjustTE(WindowDataPtr pData, Boolean doScroll)

{

    TEPtr       te;

    short       value;

    short       prevValue;

    te = *((TextDataPtr) pData)->hTE;

    prevValue = GetControlValue(pData->vScroll);

    value = te->viewRect.top - te->destRect.top;

    SetControlValue(pData->vScroll, value);

    te = *((TextDataPtr) pData)->hTE;

    if (doScroll)

        {

        short   hScroll = te->viewRect.left - te->destRect.left;

        short   vScroll = value - prevValue;

        if ((hScroll != 0) || (vScroll != 0))

            TEScroll(hScroll, vScroll, ((TextDataPtr) pData)->hTE);

        }

} // AdjustTE

// --------------------------------------------------------------------------------------------------------------

static void RecalcTE(WindowDataPtr pData, Boolean doInval)

{

    Rect    viewRect, destRect;

    short   oldOffset;

    destRect = (**((TextDataPtr) pData)->hTE).destRect;

    viewRect = (**((TextDataPtr) pData)->hTE).viewRect;

    oldOffset = destRect.top - viewRect.top;

    viewRect = pData->contentRect;

    InsetRect(&viewRect, kMargins, kMargins);

    destRect = viewRect;

    OffsetRect(&destRect, 0, oldOffset);

    (**((TextDataPtr) pData)->hTE).viewRect = viewRect;

    (**((TextDataPtr) pData)->hTE).destRect = destRect;

    TECalText(((TextDataPtr) pData)->hTE);

    if (doInval)

        InvalRect(&qd.thePort->portRect);

} // RecalcTE

// --------------------------------------------------------------------------------------------------------------

pascal TEClickLoopUPP GetOldClickLoop(void)

{

    return ((TextDataPtr) FrontWindow())->docClick;

} // GetOldClikLoop

pascal void TextClickLoop(void)

{   

    WindowRef   window;

    RgnHandle   region;

    window = FrontWindow();

    region = NewRgn();

    GetClip(region);                    /* save clip */

    ClipRect(&GetWindowPort(window)->portRect);

    ((TextDataPtr) window)->insideClickLoop = true;

        AdjustScrollBars(window, false, false, nil);

    ((TextDataPtr) window)->insideClickLoop = false;

    SetClip(region);                    /* restore clip */

    DisposeRgn(region);

} // TextClickLoop

#if GENERATINGPOWERPC

static pascal Boolean CClikLoop(TEPtr pTE)

{

    CallTEClickLoopProc(GetOldClickLoop(), pTE);

    TextClickLoop();

    return(true);

} // CClikLoop

    static RoutineDescriptor gMyClickLoopRD = BUILD_ROUTINE_DESCRIPTOR(uppTEClickLoopProcInfo, CClikLoop);

    static TEClickLoopUPP gMyClickLoop = &gMyClickLoopRD;

#else

    static TEClickLoopUPP gMyClickLoop = NewDrawHookProc(AsmClikLoop);

#endif

// --------------------------------------------------------------------------------------------------------------

#if GENERATINGPOWERPC

pascal void MyDrawHook ( unsigned short offset, unsigned short textLen,

     Ptr textPtr, TEPtr tePtr, TEHandle teHdl )

#else

pascal void MyDrawGlue();

pascal void MyDrawHook ( TEHandle teHdl, TEPtr tePtr, Ptr textPtr, short textLen, short offset )

#endif

{

#pragma unused  ( teHdl, tePtr)

    register short          drawLen = 0;

    register Ptr            drawPtr;

    drawPtr = textPtr + (long)offset;

    while ( textLen--)

        {

        if ( *drawPtr == 0xCA &&

             ( *(drawPtr - 1) == 0x0D || *tePtr->hText == textPtr) )

            {

            DrawText( textPtr, offset, drawLen);

            DrawChar( '\040');

            offset += drawLen + 1;

            drawLen = 0;

            }

        else

            {

            ++drawLen;

            }

        ++drawPtr;

        }

    DrawText( textPtr, offset, drawLen);

} // MyDrawHook

#if GENERATINGCFM

    static RoutineDescriptor gMyDrawGlueRD = BUILD_ROUTINE_DESCRIPTOR(uppDrawHookProcInfo, MyDrawHook);

    static DrawHookUPP gMyDrawGlue = &gMyDrawGlueRD;

#else

    static DrawHookUPP gMyDrawGlue = NewDrawHookProc(MyDrawGlue);

#endif

// --------------------------------------------------------------------------------------------------------------

static void DisposeOfSpeech(Boolean throwAway)

{

    if (gSpeechChannel)

        {

        (void) StopSpeech( gSpeechChannel );

        if (throwAway)

            {

            (void) DisposeSpeechChannel( gSpeechChannel );

            gSpeechChannel = nil;

            }

        }

    if (gSpeakPtr)

        {

        DisposePtr(gSpeakPtr);

        gSpeakPtr = nil;

        }

} // DisposeOfSpeech

// --------------------------------------------------------------------------------------------------------------

static Boolean FindNextPicture(Handle textHandle, short *offset, short *delta)

{

    long result;

    // marker at begining of document means a picture there

    if ( (*offset == 0) && ( (*(unsigned char*)(*textHandle + (*offset))) == 0xCA) )

        {

        *delta = 1;

        return true;

        }

    if (gPictMarker1[0] != 0)

        {

        result = Munger(textHandle, *offset, &gPictMarker1[1], gPictMarker1[0], nil, 0);

        if (result >= 0)

            {

            *offset = result;

            *delta = gPictMarker1[0];

            return true;

            }

        }

    if (gPictMarker2[0] != 0)

        {

        result = Munger(textHandle, *offset, &gPictMarker2[1], gPictMarker2[0], nil, 0);

        if (result >= 0)

            {

            *offset = result;

            *delta = gPictMarker2[0];

            return true;

            }

        }

    *delta = 1;

    return false;

} // FindNextPicture

// --------------------------------------------------------------------------------------------------------------

static Boolean LineHasPageBreak(short lineNum, TEHandle hTE)

{

    Boolean     result = false;

    short       offset, delta, lineStartOffset;

    short       textLength;

    Handle      textHandle;

    short       pictIndex = 0;

    textHandle = (** hTE).hText;

    lineStartOffset = (**hTE).lineStarts[lineNum];

    textLength = (**hTE).lineStarts[lineNum+1];

    offset = 0;

    while (offset < textLength)

        {

        if (FindNextPicture(textHandle, &offset, &delta))

            {

            Handle  formHandle;

            formHandle = Get1Resource(kFormResource, kFormResource + pictIndex);

            if (formHandle)

                {

                long    options = **(long**)formHandle;

                ReleaseResource(formHandle);

                if ( (options & kFormFeed) && (offset >= lineStartOffset) && (offset < textLength) )

                    {

                    result = true;

                    break;

                    }

                }

            ++pictIndex;

            }

        offset += delta;

        }

    return(result);

} // LineHasPageBreak

// --------------------------------------------------------------------------------------------------------------

#define USE_PICT_SPOOL_CACHE 1

enum {kSpoolCacheBlockSize = 1024};     // 1K is arbitrary, perhaps could be tuned

static Handle   gSpoolPicture;

static long     gSpoolOffset;

static Handle   gSpoolCacheBlock;

static long     gSpoolCacheOffset;

static long     gSpoolCacheSize;

// --------------------------------------------------------------------------------------------------------------

/*

    ReadPartialResource is very painful over slow links such as ARA or ISDN. This code implements a simple

    cache that vastly improves the performance of displaying embedded pictures over a slow network link.

    The cache also improves scrolling performance in documents with many embedded pictures, even on local

    volumes.

*/

static short ReadPartialData(Ptr dataPtr, short byteCount)

{

#if USE_PICT_SPOOL_CACHE

    if (gSpoolCacheBlock == NULL)

        {

        gSpoolCacheBlock = NewHandle(kSpoolCacheBlockSize);

        if (gSpoolCacheBlock != NULL)

            {

            long    cacheBytes  = GetResourceSizeOnDisk(gSpoolPicture) - gSpoolOffset;

            if (cacheBytes > kSpoolCacheBlockSize)

                cacheBytes = kSpoolCacheBlockSize;

            HLock(gSpoolCacheBlock);

            ReadPartialResource(gSpoolPicture, gSpoolOffset, *gSpoolCacheBlock, cacheBytes);

            HUnlock(gSpoolCacheBlock);

            gSpoolCacheOffset = gSpoolOffset;

            gSpoolCacheSize = cacheBytes;

            }

        }

    // if the requested data is entirely present in the cache block, get it from thereÉ

    if (gSpoolCacheBlock != NULL &&

        gSpoolOffset >= gSpoolCacheOffset && gSpoolOffset + byteCount <= gSpoolCacheOffset + gSpoolCacheSize)

        {

        BlockMoveData(*gSpoolCacheBlock + (gSpoolOffset - gSpoolCacheOffset), dataPtr, byteCount);

        return byteCount;

        }

    // Éelse read it directly from disk, and force the cache block to be filled with new data

    else

        {

        ReadPartialResource(gSpoolPicture, gSpoolOffset, dataPtr, byteCount);

        if (gSpoolCacheBlock != NULL)

            {

            DisposeHandle(gSpoolCacheBlock);

            gSpoolCacheBlock = NULL;

            }

        return byteCount;

        }

#else

    ReadPartialResource(gSpoolPicture, gSpoolOffset, dataPtr, byteCount);

    return byteCount;

#endif

} // ReadPartialData

// --------------------------------------------------------------------------------------------------------------

static pascal void GetPartialPICTData(Ptr dataPtr,short byteCount)

{

    while (byteCount > 0)

    {

        short   readBytes   = ReadPartialData(dataPtr, byteCount);

        byteCount -= readBytes;

        dataPtr += readBytes;

        gSpoolOffset += readBytes;

    }

} // GetPartialPICTData

#if GENERATINGCFM

    static RoutineDescriptor gGetPartialPICTDataRD = BUILD_ROUTINE_DESCRIPTOR(uppQDGetPicProcInfo, GetPartialPICTData);

    static QDGetPicUPP gGetPartialPICTData = &gGetPartialPICTDataRD;

#else

    static QDGetPicUPP gGetPartialPICTData = NewQDGetPicProc(GetPartialPICTData);

#endif

// --------------------------------------------------------------------------------------------------------------

static void SpoolDrawPicture(Handle spoolPicture, PicHandle pictureHeader, Rect *pRect)

{

    CQDProcs    spoolProcs;

    QDProcs     *oldProcs;

    gSpoolPicture = spoolPicture;

    gSpoolOffset = sizeof(Picture);

    if (gMachineInfo.theEnvirons.hasColorQD)

        SetStdCProcs(&spoolProcs);

    else

        SetStdProcs((QDProcs*) &spoolProcs);

    spoolProcs.getPicProc = gGetPartialPICTData;

    oldProcs = qd.thePort->grafProcs;

    qd.thePort->grafProcs = (QDProcs*) &spoolProcs;

        DrawPicture(pictureHeader, pRect);

    qd.thePort->grafProcs = oldProcs;

    if (gSpoolCacheBlock != NULL)

        {

        DisposeHandle(gSpoolCacheBlock);

        gSpoolCacheBlock = NULL;

        }

} // SpoolDrawPicture

// --------------------------------------------------------------------------------------------------------------

static void DrawPictures( WindowDataPtr pData, TEHandle hTE)

{

    Handle  textHandle;

    long    textLength;

    short   oldResFile;

    short   pictIndex;

    short   numPicts;

    oldResFile = CurResFile();

    UseResFile(pData->resRefNum);

    numPicts = Count1Resources('PICT');

    pictIndex = 0;

    if (numPicts != 0)

        {

        short               offset, delta;

        RgnHandle           oldClip;

        Rect                theRect;

        Rect                viewRect;

        viewRect = theRect = (** hTE).viewRect;

        // intersect our viewing area with the actual clip to avoid

        // drawing over the scroll bars

            {

            RgnHandle   newClip = NewRgn();

            oldClip = NewRgn();

            GetClip(oldClip);

            RectRgn(newClip, &theRect);

            SectRgn(oldClip, newClip, newClip);

            SetClip(newClip);

            }

        textHandle = (** hTE).hText;

        textLength = (** hTE).teLength;

        offset = 0;

        while (offset < textLength)

            {

            if (FindNextPicture(textHandle, &offset, &delta))

                {

                Handle      pictHandle;

                Point       picturePoint = TEGetPoint(offset, hTE);

                SetResLoad(false);

                pictHandle = Get1Resource('PICT', kPictureBase + pictIndex);

                SetResLoad(true);

                if (pictHandle)

                    {

                    PicHandle   pictHeader = (PicHandle)NewHandle(sizeof(Picture) + sizeof(long)*8);

                    if (pictHeader)

                        {

                        HLock((Handle) pictHeader);

                        ReadPartialResource(pictHandle, 0, (Ptr)*pictHeader, GetHandleSize((Handle)pictHeader));

                        HUnlock((Handle) pictHeader);

                        // calculate where to draw the picture, this location is

                        // computed by:

                        //  1) the frame of the original picture, normalized to 0,0

                        //  2) the location of the non-breaking space character

                        //  3) centering the picture on the content frame horizontally

                        //  4) subtracting off the line-height of the character

                        GetPICTRectangleAt72dpi(pictHeader, &theRect);

                        OffsetRect(&theRect, -theRect.left, -theRect.top);

                        OffsetRect(&theRect, 

                                            theRect.left +

                                            ((viewRect.right - viewRect.left) >> 1) -

                                            ((theRect.right - theRect.left) >> 1),

                                        picturePoint.v-theRect.top - pData->vScrollAmount);

                        // only draw the picture if it will be visible (vastly improves scrolling

                        // performance in documents with many embedded pictures)

                        if (RectInRgn(&theRect, qd.thePort->clipRgn))

                            SpoolDrawPicture(pictHandle, pictHeader, &theRect);

                        }

                    ReleaseResource((Handle) pictHandle);

                    }

                ++pictIndex;

                offset += delta;

                }

            else

                break;

            }

        SetClip(oldClip);

        DisposeRgn(oldClip);

        }

    UseResFile(oldResFile);

} // DrawPictures

// --------------------------------------------------------------------------------------------------------------

static void UpdateFileInfo(FSSpec *pSpec, Boolean documentIsText)

{

    FInfo   theInfo;

    FSpGetFInfo(pSpec, &theInfo);

    theInfo.fdCreator = 'ttxt';

    // set the stationary bit, if we must

    if (!documentIsText)

        {

        theInfo.fdFlags |= kIsStationery;

        theInfo.fdType = 'sEXT';

        }

    else

        {

        theInfo.fdFlags &= ~kIsStationery;

        theInfo.fdType = 'TEXT';

        }

    FSpSetFInfo(pSpec, &theInfo);

} // UpdateFileInfo

// --------------------------------------------------------------------------------------------------------------

static OSErr    TextSave(WindowDataPtr pData)

{

    OSErr   anErr = noErr;

    long    amountToWrite;

    // write out the text

    SetFPos(pData->dataRefNum, fsFromStart, 0);

    amountToWrite = (** ((TextDataPtr) pData)->hTE).teLength;

    anErr = FSWrite(pData->dataRefNum, &amountToWrite, * (** ((TextDataPtr) pData)->hTE).hText);

    nrequire(anErr, FailedWrite);

    SetEOF(pData->dataRefNum, amountToWrite);

    if (pData->resRefNum == -1)

        {

        FSpCreateResFile(&pData->fileSpec, 'ttxt', pData->originalFileType, 0);

        pData->resRefNum = FSpOpenResFile(&pData->fileSpec, fsRdWrPerm);            

        }

    else

        {

        // a save always makes it into file of type 'TEXT', for Save AsÉ we 

        // afterwards set it again if the user is saving as stationary.

        UpdateFileInfo(&pData->fileSpec, true);

        }

    if (pData->resRefNum != -1)

        {

        short   oldResFile = CurResFile();

        Handle  resourceHandle;

        UseResFile(pData->resRefNum);

        // remove any old sounds

        resourceHandle = Get1Resource('snd ', kSoundBase);

        if (resourceHandle)

            {

            RemoveResource(resourceHandle);

            DisposeHandle(resourceHandle);

            }

        // save the new sound

        resourceHandle = ((TextDataPtr) pData)->soundHandle;

        if (resourceHandle)

            {

            anErr = HandToHand(&resourceHandle);

            if (anErr == noErr)

                {

                AddResource(resourceHandle, 'snd ', kSoundBase, "\p");

                anErr = ResError();

                }

            nrequire(anErr, AddSoundResourceFailed);

            }

        // remove any old styles

        resourceHandle = Get1Resource('styl', 128);

        if (resourceHandle)

            {

            RemoveResource(resourceHandle);

            DisposeHandle(resourceHandle);

            }

        // save the new style -- get the scrap handle from the TE record

        // To do this, we must select the text -- BUT doing so through the

        // TextEdit API results in lots of flashing and annoying behavior.

        // So we just change the offsets by hand

        {

        short               oldStart, oldEnd;   

        oldStart = (** ((TextDataPtr) pData)->hTE).selStart;

        oldEnd   = (** ((TextDataPtr) pData)->hTE).selEnd;

        (** ((TextDataPtr) pData)->hTE).selStart = 0;

        (** ((TextDataPtr) pData)->hTE).selEnd = 32767;

        resourceHandle = (Handle) TEGetStyleScrapHandle( ((TextDataPtr) pData)->hTE );

        (** ((TextDataPtr) pData)->hTE).selStart = oldStart;

        (** ((TextDataPtr) pData)->hTE).selEnd = oldEnd;

        }

        if (resourceHandle)

            {

            AddResource(resourceHandle, 'styl', 128, "\p");

            anErr = ResError();

            nrequire(anErr, AddStyleResourceFailed);

            }

        AddSoundResourceFailed:

        AddStyleResourceFailed: 

            UpdateResFile(pData->resRefNum);

            UseResFile(oldResFile);

        }

// FALL THROUGH EXCEPTION HANDLING

FailedWrite:

    // if everything went okay, then clear the changed bit

    if (anErr == noErr)

        {

        pData->changed = false;

        (void) FlushVol("\p", pData->fileSpec.vRefNum);

        }

    return anErr;

} // TextSave

// --------------------------------------------------------------------------------------------------------------

static pascal void DrawTextUserItem(DialogPtr dPtr, short theItem)

/*

    Draw text icon in the location

*/

{

    short       kind;

    Handle      itemHandle;

    Rect        box;

    GetDialogItem(dPtr, theItem, &kind, &itemHandle, &box);

    PlotIconID(&box, ttNone, ttNone, kTextIcon);

} // DrawTextUserItem

#if GENERATINGCFM

    static RoutineDescriptor gDrawTextUserItemRD = BUILD_ROUTINE_DESCRIPTOR(uppUserItemProcInfo, DrawTextUserItem);

    static UserItemUPP gDrawTextUserItem = &gDrawTextUserItemRD;

#else

    static UserItemUPP gDrawTextUserItem = NewUserItemProc(DrawTextUserItem);

#endif

// --------------------------------------------------------------------------------------------------------------

static pascal void DrawStationeryUserItem(DialogPtr dPtr, short theItem)

/*

    Draw stationery icon in the location

*/

{

    short       kind;

    Handle      itemHandle;

    Rect        box;

    GetDialogItem(dPtr, theItem, &kind, &itemHandle, &box);

    PlotIconID(&box, ttNone, ttNone, kStationeryIcon);

} // DrawStationeryUserItem

#if GENERATINGCFM

    static RoutineDescriptor gDrawStationeryUserItemRD = BUILD_ROUTINE_DESCRIPTOR(uppUserItemProcInfo, DrawStationeryUserItem);

    static UserItemUPP gDrawStationeryUserItem = &gDrawStationeryUserItemRD;

#else

    static UserItemUPP gDrawStationeryUserItem = NewUserItemProc(DrawStationeryUserItem);

#endif

// --------------------------------------------------------------------------------------------------------------

// pre and post update procs for inline input 

static pascal void TSMPreUpdateProc(TEHandle textH, long refCon)

{

#pragma unused (refCon)

    ScriptCode  keyboardScript;

    short       mode;

    TextStyle   theStyle;

    keyboardScript = GetScriptManagerVariable(smKeyScript);

    mode = doFont;

    if  (!

            (

            (TEContinuousStyle(&mode, &theStyle, textH) )&& 

            (FontToScript(theStyle.tsFont) == keyboardScript) 

            )

        )

        {

        theStyle.tsFont = GetScriptVariable(keyboardScript, smScriptAppFond);

        TESetStyle(doFont, &theStyle, false, textH);

        }

} // TSMPreUpdateProc

#if GENERATINGCFM

    static RoutineDescriptor gTSMPreUpdateProcRD = BUILD_ROUTINE_DESCRIPTOR(uppTSMTEPreUpdateProcInfo, TSMPreUpdateProc);

    static TSMTEPreUpdateUPP gTSMPreUpdateProc = &gTSMPreUpdateProcRD;

#else

    static TSMTEPreUpdateUPP gTSMPreUpdateProc = NewTSMTEPreUpdateProc(TSMPreUpdateProc);

#endif

static pascal void TSMPostUpdateProc(

                TEHandle textH,

                long fixLen,

                long inputAreaStart,

                long inputAreaEnd,

                long pinStart,

                long pinEnd,

                long refCon)

{

#pragma unused (textH, fixLen, inputAreaStart, inputAreaEnd, pinStart, pinEnd)

    AdjustScrollBars((WindowRef)refCon, false, false, nil);

    AdjustTE((WindowDataPtr)refCon, true);

    ((WindowDataPtr)refCon)->changed = true;

} // TSMPostUpdateProc

#if GENERATINGCFM

    static RoutineDescriptor gTSMPostUpdateProcRD = BUILD_ROUTINE_DESCRIPTOR(uppTSMTEPostUpdateProcInfo, TSMPostUpdateProc);

    static TSMTEPostUpdateUPP gTSMPostUpdateProc = &gTSMPostUpdateProcRD;

#else

    static TSMTEPostUpdateUPP gTSMPostUpdateProc = NewTSMTEPostUpdateProc(TSMPostUpdateProc);

#endif

// --------------------------------------------------------------------------------------------------------------

static pascal short SaveDialogHook(short item, DialogPtr dPtr, Boolean *isText)

{

    short   theType;

    Handle  theHandle;

    Rect    theRect;

    short   returnValue = item;

    switch (item)

        {

        case sfHookFirstCall:

            if (GetWRefCon(GetDialogWindow(dPtr)) == sfMainDialogRefCon)

                {

                GetDialogItem(dPtr, iTextUserItem, &theType, &theHandle, &theRect);

                theHandle = (Handle) gDrawTextUserItem;

                SetDialogItem(dPtr, iTextUserItem, theType, theHandle, &theRect);

                GetDialogItem(dPtr, iStationeryUserItem, &theType, &theHandle, &theRect);

                theHandle = (Handle) gDrawStationeryUserItem;

                SetDialogItem(dPtr, iStationeryUserItem, theType, theHandle, &theRect);

                GetDialogItem(dPtr, iTextDocumentItem, &theType, &theHandle, &theRect);

                SetControlValue((ControlHandle) theHandle, 1);

                GetDialogItem(dPtr, iStationeryDocumentItem, &theType, &theHandle, &theRect);

                SetControlValue((ControlHandle) theHandle, 0);

                *isText = true;

                }

            break;

        case iTextDocumentItem:

        case iTextUserItem:

            GetDialogItem(dPtr, iTextDocumentItem, &theType, &theHandle, &theRect);

            SetControlValue((ControlHandle) theHandle, 1);

            GetDialogItem(dPtr, iStationeryDocumentItem, &theType, &theHandle, &theRect);

            SetControlValue((ControlHandle) theHandle, 0);

            *isText = true;

            returnValue = sfHookNullEvent;

            break;

        case iStationeryDocumentItem:

        case iStationeryUserItem:

            GetDialogItem(dPtr, iTextDocumentItem, &theType, &theHandle, &theRect);

            SetControlValue((ControlHandle) theHandle, 0);

            GetDialogItem(dPtr, iStationeryDocumentItem, &theType, &theHandle, &theRect);

            SetControlValue((ControlHandle) theHandle, 1);

            *isText = false;

            returnValue = sfHookNullEvent;

            break;

        }

    return returnValue;

} // SaveDialogHook

#if GENERATINGCFM

    static RoutineDescriptor gSaveDialogHookRD = BUILD_ROUTINE_DESCRIPTOR(uppDlgHookYDProcInfo, SaveDialogHook);

    static DlgHookYDUPP gSaveDialogHook = &gSaveDialogHookRD;

#else

    static DlgHookYDUPP gSaveDialogHook = NewDlgHookYDProc(SaveDialogHook);

#endif

// --------------------------------------------------------------------------------------------------------------

// Handle update/activate events behind Standard File

static pascal Boolean SaveDialogFilter(DialogPtr theDialog, EventRecord *theEvent,

                                      short *itemHit, void *myDataPtr)

{

    #pragma unused(myDataPtr)

    if (StdFilterProc(theDialog, theEvent, itemHit))

        return true;

    // Pass updates through (Activates are tricky...was mucking with Apple menu & thereby

    // drastically changing how the system handles the menu bar during our alert)

    if (theEvent->what == updateEvt /* || theEvent->what == activateEvt */ )

        {

        HandleEvent(theEvent);

        }

    return false;

} // SaveDialogFilter

#if GENERATINGCFM

    static RoutineDescriptor gSaveDialogFilterRD = BUILD_ROUTINE_DESCRIPTOR(uppModalFilterYDProcInfo, SaveDialogFilter);

    static ModalFilterYDUPP gSaveDialogFilter = &gSaveDialogFilterRD;

#else

    static ModalFilterYDUPP gSaveDialogFilter = NewModalFilterYDProc(SaveDialogFilter);

#endif

// --------------------------------------------------------------------------------------------------------------

static OSErr    TextSaveAs(WindowRef pWindow, WindowDataPtr pData)

{

    OSErr               anErr = noErr;

    short               oldRes, oldData;

    StandardFileReply   sfReply;

    Boolean             documentIsText;

    // save the old references -- if there is an error, we restore them

    oldRes = pData->resRefNum;

    oldData = pData->dataRefNum;

    // ask where and how to save this document

    {

    Str255  defaultName;

    Point   where = {-1, -1};

    // setup for the call

    GetWTitle(pWindow, defaultName);

    SetCursor(&qd.arrow);

    // find out where the user wants the file

    CustomPutFile("\p", defaultName, &sfReply, 

                kTextSaveAsDialogID, where,

                gSaveDialogHook, gSaveDialogFilter, nil, nil, &documentIsText);

    // map the cancel button into a cancelling error

    if (!sfReply.sfGood)

        anErr = eUserCanceled;

    }

    // can't replace over other types   

    if (sfReply.sfReplacing)

        {

        FInfo   theInfo;

        FSpGetFInfo(&sfReply.sfFile, &theInfo);

        if ( (theInfo.fdType != 'TEXT') && (theInfo.fdType != 'sEXT') )

            anErr = eDocumentWrongKind;

        }

    nrequire(anErr, StandardPutFile);

    if  (

        (sfReply.sfReplacing) && 

        (oldData != -1) && 

        (pData->fileSpec.vRefNum == sfReply.sfFile.vRefNum) &&

        (pData->fileSpec.parID == sfReply.sfFile.parID) &&

        EqualString(pData->fileSpec.name, sfReply.sfFile.name, false, false)

        )

        {

        anErr = TextSave(pData);

        if (anErr == noErr)

            UpdateFileInfo(&sfReply.sfFile, documentIsText);

        }

    else

        {

        // create the data file and resource fork

        (void) FSpDelete(&sfReply.sfFile);

        anErr = FSpCreate(&sfReply.sfFile, 'ttxt', documentIsText ? 'TEXT' : 'sEXT', 0);

        FSpCreateResFile(&sfReply.sfFile, 'ttxt', documentIsText ? 'TEXT' : 'sEXT', 0);

        nrequire(anErr, FailedCreate);

        // set the stationary bit, if we must

        if (!documentIsText)

            {

            FInfo   theInfo;

            FSpGetFInfo(&sfReply.sfFile, &theInfo);

            theInfo.fdFlags |= kIsStationery;

            FSpSetFInfo(&sfReply.sfFile, &theInfo);

            }

        // open both of forks

        anErr = FSpOpenDF(&sfReply.sfFile, fsRdWrPerm, &pData->dataRefNum);

        if (anErr == noErr)

            {

            pData->resRefNum = FSpOpenResFile(&sfReply.sfFile, fsRdWrPerm);

            anErr = ResError();

            }

        nrequire(anErr, FailedOpen);

        // call the standard save function to do the save

        anErr = TextSave(pData);

    // FALL THROUGH EXCEPTION HANDLING

    FailedOpen:

        FSpDelete(&sfReply.sfFile); 

    FailedCreate:

    StandardPutFile:

        // finally, close the old files if everything went okay

        if (anErr == noErr)

            {

            if (oldRes != -1)

                CloseResFile(oldRes);

            if (oldData != -1)

                FSClose(oldData);

            pData->isWritable = true;

            SetWTitle(pWindow, sfReply.sfFile.name);

            }

        else

            {

            pData->resRefNum = oldRes;

            pData->dataRefNum = oldData;

            }

        }

    // save new location

    if (anErr == noErr)

        BlockMoveData(&sfReply.sfFile, &pData->fileSpec, sizeof(FSSpec));

// Return eUserCanceled so we can avoid closing/quitting if they cancel the SF dialog

//  // don't propagate this error

//  if (anErr == eUserCanceled)

//      anErr = noErr;

    return anErr;

} // TextSaveAs

// --------------------------------------------------------------------------------------------------------------

static void ApplyFace(short requestedFace, WindowRef pWindow, WindowDataPtr pData, short commandID)

{

    TextStyle   style;

    short       oldNumLines = (**(((TextDataPtr) pData)->hTE)).nLines;

    SaveCurrentUndoState(pData, commandID);

    style.tsFace = requestedFace;

    TESetStyle(doFace + ((requestedFace != normal) ? doToggle : 0), &style, true, ((TextDataPtr) pData)->hTE);

    TECalText(((TextDataPtr) pData)->hTE);

    oldNumLines -= (**(((TextDataPtr) pData)->hTE)).nLines;

    AdjustTE(pData, false);

    AdjustScrollBars(pWindow, (oldNumLines > 0), (oldNumLines > 0), nil);

    pData->changed = true;

} // ApplyFace

// --------------------------------------------------------------------------------------------------------------

static OSErr ApplySize(short requestedSize, WindowRef pWindow, WindowDataPtr pData, short commandID)

{

    OSErr       anErr = noErr;

    TextStyle   style;

    short       oldNumLines = (**(((TextDataPtr) pData)->hTE)).nLines;

    SaveCurrentUndoState(pData, commandID);

    style.tsSize = requestedSize;

    TESetStyle(doSize, &style, true, ((TextDataPtr) pData)->hTE);

    TECalText(((TextDataPtr) pData)->hTE);

    if (CalculateTextEditHeight(((TextDataPtr) pData)->hTE) > 32767)

        {       

        style.tsSize = 0;

        TESetStyle(doSize, &style, true, ((TextDataPtr) pData)->hTE);

        anErr = eDocumentTooLarge;

        }

    oldNumLines -= (**(((TextDataPtr) pData)->hTE)).nLines;

    AdjustTE(pData, false);

    AdjustScrollBars(pWindow, (oldNumLines > 0), (oldNumLines > 0), nil);

    pData->changed = true;

    return anErr;

} // ApplySize

// --------------------------------------------------------------------------------------------------------------

// OOP INTERFACE ROUTINES

// --------------------------------------------------------------------------------------------------------------

static OSErr    TextUpdateWindow(WindowRef pWindow, WindowDataPtr pData)

{

    Rect    updateArea = pData->contentRect;

    // be sure to also erase the area where the horizontal scroll bar

    // is missing.

    updateArea.bottom = GetWindowPort(pWindow)->portRect.bottom;

    EraseRect(&updateArea);

    TEUpdate(&pData->contentRect, ((TextDataPtr) pData)->hTE);

    DrawPictures(pData, ((TextDataPtr) pData)->hTE);

    DrawControls(pWindow);

    DrawGrowIcon(pWindow);

    return noErr;

} // TextUpdateWindow

// --------------------------------------------------------------------------------------------------------------

static OSErr    TextCloseWindow(WindowRef pWindow, WindowDataPtr pData)

{

#pragma unused (pWindow)

    // shut down text services

    if (pData->docTSMDoc)

        {

        FixTSMDocument(pData->docTSMDoc);

        DeactivateTSMDocument(pData->docTSMDoc);

        DeleteTSMDocument(pData->docTSMDoc);

        }

    DisposeOfSpeech(true);

    DisposeHandle(((TextDataPtr) pData)->soundHandle);

    TEDispose(((TextDataPtr) pData)->hTE);

    DisposeHandle(((TextDataPtr) pData)->prevText);

    DisposeHandle(((TextDataPtr) pData)->prevStyle);

    TextRemoveContentsMenu(pData);

    return noErr;

} // TextCloseWindow

// --------------------------------------------------------------------------------------------------------------

static OSErr    TextActivateEvent(WindowRef pWindow, WindowDataPtr pData, Boolean activating)

{

#pragma unused (pWindow)

    // only modifyable docs can be active

    if (pData->originalFileType == 'TEXT')

        {

        if (activating)

            {

            TEActivate(((TextDataPtr) pData)->hTE);

            if (pData->docTSMDoc != nil)

                ActivateTSMDocument(pData->docTSMDoc);

            }

        else

            {

            TEDeactivate(((TextDataPtr) pData)->hTE);

            if (pData->docTSMDoc != nil)

                DeactivateTSMDocument(pData->docTSMDoc);

            }

        }

    // add contents menu, if appropriate        

    if (activating)

        {

        TextAddContentsMenu(pData);

        }

    else

        {

        TextRemoveContentsMenu(pData);

        }

    return noErr;

} // TextActivateEvent

// --------------------------------------------------------------------------------------------------------------

static Boolean  TextFilterEvent(WindowRef pWindow, WindowDataPtr pData, EventRecord *pEvent)

{   

    switch (pEvent->what)

        {

        case nullEvent:

            if (pData->originalFileType == 'TEXT')

                {

                if ( pWindow == FrontWindow() )

                    TEIdle(((TextDataPtr) pData)->hTE);

                }

            // if we stop speaking, ditch the channel

            if (gSpeechChannel) 

                {

                SpeechStatusInfo    status;             // Status of our speech channel.

                if ( 

                    (GetSpeechInfo( gSpeechChannel, soStatus, (void*) &status ) == noErr)

                    &&  (!status.outputBusy )

                    )

                    DisposeOfSpeech(true);

                }

            break;

        }

    return false;

} // TextFilterEvent

// --------------------------------------------------------------------------------------------------------------

static OSErr    TextScrollContent(WindowRef pWindow, WindowDataPtr pData, short deltaH, short deltaV)

{

    GrafPtr     port = (GrafPtr) GetWindowPort(pWindow);

    RgnHandle   srcRgn, dstRgn;

    Rect        viewRect;

    // scroll the text area

    TEScroll(deltaH, deltaV, ((TextDataPtr) pData)->hTE);

    // calculate the region that is uncovered by the scroll

    srcRgn = NewRgn();

    dstRgn = NewRgn();

    viewRect = (**((TextDataPtr) pData)->hTE).viewRect;

    RectRgn( srcRgn, &viewRect );

    SectRgn( srcRgn, port->visRgn,  srcRgn );

    SectRgn( srcRgn, port->clipRgn, srcRgn );

    CopyRgn( srcRgn, dstRgn );

    OffsetRgn( dstRgn, deltaH, deltaV );

    SectRgn( srcRgn, dstRgn, dstRgn );

    DiffRgn( srcRgn, dstRgn, srcRgn );

    // clip to this new area

    GetClip(dstRgn);

    SetClip(srcRgn);

        DrawPictures(pData, ((TextDataPtr) pData)->hTE);

    SetClip(dstRgn);

    // all done with these calculation regions

    DisposeRgn( srcRgn );

    DisposeRgn( dstRgn );

    return eActionAlreadyHandled;

} // TextScrollContent

// --------------------------------------------------------------------------------------------------------------

static OSErr    TextKeyEvent(WindowRef pWindow, WindowDataPtr pData, EventRecord *pEvent, Boolean isMotionKey)

{   

    OSErr   anErr = noErr;

    if (!(pEvent->modifiers & cmdKey)) 

        {

        char    theKey = pEvent->message & charCodeMask;

        char    theKeyCode = (pEvent->message >> 8) & charCodeMask;

        if ( ((theKey != kDeleteKey) || (theKeyCode != kForwardDeleteKey)) && 

            ((** ((TextDataPtr) pData)->hTE).teLength+1 > kMaxLength) )

            anErr = eDocumentTooLarge;

        else

            {

            long        oldHeight = CalculateTextEditHeight(((TextDataPtr) pData)->hTE);

            long        end = (**(((TextDataPtr) pData)->hTE)).selEnd;

            long        start = (**(((TextDataPtr) pData)->hTE)).selStart;

            ObscureCursor();

            SaveCurrentUndoState(pData, cTypingCommand);

            if (theKeyCode != kForwardDeleteKey)

                {

                if (pEvent->modifiers & shiftKey)

                    {

                    switch (theKeyCode)

                        {

                        case kUpArrow:

                            TEKey(theKey, ((TextDataPtr) pData)->hTE);

                            TESetSelect((**(((TextDataPtr) pData)->hTE)).selStart, end, ((TextDataPtr) pData)->hTE);

                            break;

                        case kDownArrow:

                            TESetSelect(end, end, ((TextDataPtr) pData)->hTE);

                            TEKey(theKey, ((TextDataPtr) pData)->hTE);

                            TESetSelect(start, (**(((TextDataPtr) pData)->hTE)).selEnd, ((TextDataPtr) pData)->hTE);

                            break;

                        case kRightArrow:

                            {

                            Handle textHandle = (**(((TextDataPtr) pData)->hTE)).hText;

                            Ptr textBuf;

                            char state;

                            state = HGetState(textHandle);

                            HLock(textHandle);

                            textBuf = *(**(((TextDataPtr) pData)->hTE)).hText;

                            if (CharacterByteType(textBuf, start, smCurrentScript) != smSingleByte)

                                ++end;

                            HSetState(textHandle, state);

                            TESetSelect(start, ++end, ((TextDataPtr) pData)->hTE);

                            }

                            break;

                        case kLeftArrow:

                            if (start > 0)

                                {

                                if (start > 1)

                                    {

                                    Handle textHandle = (**(((TextDataPtr) pData)->hTE)).hText;

                                    Ptr textBuf;

                                    char state;

                                    state = HGetState(textHandle);

                                    HLock(textHandle);

                                    textBuf = *(**(((TextDataPtr) pData)->hTE)).hText;

                                    if (CharacterByteType(textBuf, start-1, smCurrentScript) != smSingleByte)

                                        --start;

                                    HSetState(textHandle, state);

                                    }

                                TESetSelect(--start, end, ((TextDataPtr) pData)->hTE);

                                }

                            break;

                        default:

                            TEKey(theKey, ((TextDataPtr) pData)->hTE);

                        }

                    }

                else

                    TEKey(theKey, ((TextDataPtr) pData)->hTE);

                }

            else

                {

                if  (end < (**(((TextDataPtr) pData)->hTE)).teLength)

                    {

                    if (start == end)

                        TEKey(kRightArrowCharCode, ((TextDataPtr) pData)->hTE);

                    TEKey(kBackspaceCharCode, ((TextDataPtr) pData)->hTE);

                    }

                }

            oldHeight -= CalculateTextEditHeight(((TextDataPtr) pData)->hTE);

            ((TextDataPtr) pWindow)->insideClickLoop = true;

                AdjustTE(pData, false);

                AdjustScrollBars(pWindow, (oldHeight > 0), (oldHeight > 0), nil);

            ((TextDataPtr) pWindow)->insideClickLoop = false;

            if (!isMotionKey)

                pData->changed = true;

            }

        }

    return anErr;

} // TextKeyEvent

// --------------------------------------------------------------------------------------------------------------

static OSErr    TextContentClick(WindowRef pWindow, WindowDataPtr pData, EventRecord *pEvent)

{

    OSErr           anErr = noErr;

    Point           clickPoint = pEvent->where;

    ControlHandle   theControl;

    RgnHandle       hilightRgn;

    GlobalToLocal(&clickPoint);

    if (FindControl(clickPoint, pWindow, &theControl) == 0)

        {

        if (gMachineInfo.haveDragMgr)

            {

            hilightRgn = NewRgn();

            TEGetHiliteRgn(hilightRgn, ((TextDataPtr) pData)->hTE);

            if (PtInRgn(clickPoint, hilightRgn))

                {

                SaveCurrentUndoState(pData, cTypingCommand);

                if (!DragText(pWindow, pData, pEvent, hilightRgn))

                    anErr = eActionAlreadyHandled;

                }

            else        

                {

                anErr = eActionAlreadyHandled;

                }

            DisposeRgn(hilightRgn);

            }

        else

            {

            anErr = eActionAlreadyHandled;

            }

        }

    if ( (anErr == eActionAlreadyHandled) && (PtInRect(clickPoint, &pData->contentRect)) )

        {

        TEClick(clickPoint, (pEvent->modifiers & shiftKey) != 0, ((TextDataPtr) pData)->hTE);

        }

    return anErr;

} // TextContentClick

// --------------------------------------------------------------------------------------------------------------

static OSErr    TextAdjustSize(WindowRef pWindow, WindowDataPtr pData, 

            Boolean *didReSize) // input: was window resized, output: t->we resized something

{

#pragma unused (pWindow)

    if (*didReSize)

        {

        RecalcTE(pData, true);

        AdjustTE(pData, true);

        }

    else

        {

        AdjustTE(pData, false);

        }

    return noErr;

} // TextAdjustSize

// --------------------------------------------------------------------------------------------------------------

static OSErr    TextCommand(WindowRef pWindow, WindowDataPtr pData, short commandID, long menuResult)

{

    OSErr   anErr = noErr;

    SetPort((GrafPtr) GetWindowPort(pWindow));

    if ( (pData->docTSMDoc) && (menuResult != 0) )

        FixTSMDocument(pData->docTSMDoc);

    switch (commandID)

        {           

        case cUndo:

            {

            short       oldNumLines = (**(((TextDataPtr) pData)->hTE)).nLines;

            PerformUndo(pData);

            oldNumLines -= (**(((TextDataPtr) pData)->hTE)).nLines;

            AdjustTE(pData, false);

            AdjustScrollBars(pWindow, (oldNumLines > 0), (oldNumLines > 0), nil);

            RecalcTE(pData, true);

            pData->changed = true;

            }

            break;

        case cCut:

            SaveCurrentUndoState(pData, cCut);

            {

            short       oldNumLines = (**(((TextDataPtr) pData)->hTE)).nLines;

            TECut(((TextDataPtr) pData)->hTE);  // no need for TEToScrap with styled TE record

            oldNumLines -= (**(((TextDataPtr) pData)->hTE)).nLines;

            AdjustTE(pData, false);

            AdjustScrollBars(pWindow, (oldNumLines > 0), (oldNumLines > 0), nil);

            pData->changed = true;

            }

            break;

        case cCopy:

            TECopy(((TextDataPtr) pData)->hTE); // no need for TEToScrap with styled TE record

            AdjustTE(pData, false);

            break;

        case cClear:

            SaveCurrentUndoState(pData, cClear);

            {

            short       oldNumLines = (**(((TextDataPtr) pData)->hTE)).nLines;

            TEDelete(((TextDataPtr) pData)->hTE);

            oldNumLines -= (**(((TextDataPtr) pData)->hTE)).nLines;

            AdjustTE(pData, false);

            AdjustScrollBars(pWindow, (oldNumLines > 0), (oldNumLines > 0), nil);

            pData->changed = true;

            }

            break;

        case cPaste:

            SaveCurrentUndoState(pData, cPaste);

            {

            short       oldNumLines = (**(((TextDataPtr) pData)->hTE)).nLines;

            anErr = TEFromScrap();          

            if (anErr == noErr)

                {               

                // if the current length, plus the paste data, minus the data in the selection

                // would make the document too large, say so

                if  ( 

                        ((** ((TextDataPtr) pData)->hTE).teLength +

                        TEGetScrapLength() -

                        ((** ((TextDataPtr) pData)->hTE).selEnd-(** ((TextDataPtr) pData)->hTE).selStart)

                        )

                    > kMaxLength)

                    {

                    anErr = eDocumentTooLarge;

                    }

                else

                    {

                    Handle  aHandle = (Handle) TEGetText(((TextDataPtr) pData)->hTE);

                    Size    oldSize = GetHandleSize(aHandle);

                    Size    newSize = oldSize + TEGetScrapLength();

                    OSErr   saveErr;

                    SetHandleSize(aHandle, newSize);

                    saveErr = MemError();

                    SetHandleSize(aHandle, oldSize);

                    if (saveErr != noErr)

                        anErr = eDocumentTooLarge;

                    else

                        TEStylePaste(((TextDataPtr) pData)->hTE);

                    }

                UnloadScrap();

                }

            oldNumLines -= (**(((TextDataPtr) pData)->hTE)).nLines;

            AdjustTE(pData, false);

            AdjustScrollBars(pWindow, (oldNumLines > 0), (oldNumLines > 0), nil);

            pData->changed = true;

            }

            break;

        case cReplace:

            SaveCurrentUndoState(pData, cReplace);

            {

            short result = ConductFindOrReplaceDialog(kReplaceWindowID);

            if (result == cancel)

                break;

            if (result == iReplaceAll)

                {

                long        newStart, newEnd;

                short       oldNumLines = (**(((TextDataPtr) pData)->hTE)).nLines;

                TESetSelect(0, 0, ((TextDataPtr) pData)->hTE);

                while (PerformSearch((**((TextDataPtr) pData)->hTE).hText,

                                    (**((TextDataPtr) pData)->hTE).selStart,

                                    gFindString, gCaseSensitive, false, false,

                                    &newStart, &newEnd))

                    {

                    TESetSelect(newStart, newEnd, ((TextDataPtr) pData)->hTE);

                    TEDelete(((TextDataPtr) pData)->hTE);

                    TEInsert(&gReplaceString[1], gReplaceString[0], ((TextDataPtr) pData)->hTE);

                    TESetSelect(newStart, newStart+gReplaceString[0], ((TextDataPtr) pData)->hTE);              

                    pData->changed = true;

                    }

                oldNumLines -= (**(((TextDataPtr) pData)->hTE)).nLines;

                AdjustTE(pData, false);

                AdjustScrollBars(pWindow, (oldNumLines > 0), (oldNumLines > 0), nil);

                anErr = eActionAlreadyHandled;

                break;

                }

            }

        // fall through from replace

        case cReplaceAgain:

            SaveCurrentUndoState(pData, cReplaceAgain);

            {

            long    newStart, newEnd;

            Boolean isBackwards = ((gEvent.modifiers & shiftKey) != 0);

            if (PerformSearch((**((TextDataPtr) pData)->hTE).hText,

                                isBackwards ? (**((TextDataPtr) pData)->hTE).selEnd : (**((TextDataPtr) pData)->hTE).selStart,

                                gFindString, gCaseSensitive, isBackwards, gWrapAround,

                                &newStart, &newEnd))

                {

                short       oldNumLines = (**(((TextDataPtr) pData)->hTE)).nLines;

                TESetSelect(newStart, newEnd, ((TextDataPtr) pData)->hTE);

                TEDelete(((TextDataPtr) pData)->hTE);

                TEInsert(&gReplaceString[1], gReplaceString[0], ((TextDataPtr) pData)->hTE);

                TESetSelect(newStart, newStart+gReplaceString[0], ((TextDataPtr) pData)->hTE);              

                oldNumLines -= (**(((TextDataPtr) pData)->hTE)).nLines;

                AdjustTE(pData, false);

                AdjustScrollBars(pWindow, (oldNumLines > 0), (oldNumLines > 0), nil);

                pData->changed = true;

                }

            else

                SysBeep(1);

            anErr = eActionAlreadyHandled;

            }

            break;

        case cFind:

        case cFindSelection:

            if (commandID == cFind)

                {

                if (ConductFindOrReplaceDialog(kFindWindowID) == cancel)    

                    break;

                }

            else

                {

                gFindString[0] = (**((TextDataPtr) pData)->hTE).selEnd - (**((TextDataPtr) pData)->hTE).selStart;

                BlockMoveData( (*(**((TextDataPtr) pData)->hTE).hText) + (**((TextDataPtr) pData)->hTE).selStart, &gFindString[1], gFindString[0]);

                }

        // fall through from find or find selection

        case cFindAgain:

            {

            long    newStart, newEnd;

            Boolean isBackwards = ((gEvent.modifiers & shiftKey) != 0);

            if (PerformSearch((**((TextDataPtr) pData)->hTE).hText,

                                isBackwards ? (**((TextDataPtr) pData)->hTE).selStart : (**((TextDataPtr) pData)->hTE).selEnd,

                                gFindString, gCaseSensitive, isBackwards, gWrapAround,

                                &newStart, &newEnd))

                {

                TESetSelect(newStart, newEnd, ((TextDataPtr) pData)->hTE);

                AdjustTE(pData, false);

                AdjustScrollBars(pWindow, false, false, nil);

                }

            else

                SysBeep(1);

            anErr = eActionAlreadyHandled;

            }

            break;

        case cSelectAll:

            TESetSelect(0, (**((TextDataPtr) pData)->hTE).teLength, 

                        ((TextDataPtr) pData)->hTE);

            AdjustTE(pData, false);

            AdjustScrollBars(pWindow, false, false, nil);

            anErr = eActionAlreadyHandled;

            break;

        // save turns into save as if this is a new document or if the original wasn't

        // available for writing

        case cSave:

            if  (

                (!pData->isWritable) || 

                ( (pData->dataRefNum == -1) && (pData->resRefNum == -1) )

                )

                anErr = TextSaveAs(pWindow, pData);

            else

                anErr = TextSave(pData);

            break;

        case cSaveAs:

            anErr = TextSaveAs(pWindow, pData);

            break;

        // SUPPORTED FONTS

//      case cSelectFontStyle:          

        case cSelectFont:

            SaveCurrentUndoState(pData, cSelectFont);

            {

            Str255      itemName;

            Str255      menuName;

            TextStyle   theStyle;

            short       oldNumLines = (**(((TextDataPtr) pData)->hTE)).nLines;

            GetMenuItemText( GetMenuHandle( menuResult>>16 ), menuResult & 0xFFFF, itemName );

            GetFNum( itemName, &theStyle.tsFont );

            TESetStyle( doFont, &theStyle, true, ((TextDataPtr) pData)->hTE );

            TECalText(((TextDataPtr) pData)->hTE);

            oldNumLines -= (**(((TextDataPtr) pData)->hTE)).nLines;

            AdjustTE(pData, false);

            AdjustScrollBars(pWindow, (oldNumLines > 0), (oldNumLines > 0), nil);

            pData->changed = true;

            }

            break;

        // SUPPORTED STYLES

        case cPlain:

            ApplyFace(normal, pWindow, pData, cPlain);

            break;

        case cBold:

            ApplyFace(bold, pWindow, pData, cBold);

            break;

        case cItalic:

            ApplyFace(italic, pWindow, pData, cItalic);

            break;

        case cUnderline:

            ApplyFace(underline, pWindow, pData, cUnderline);

            break;

        case cOutline:

            ApplyFace(outline, pWindow, pData, cOutline);

            break;

        case cShadow:

            ApplyFace(shadow, pWindow, pData, cShadow);

            break;

        case cCondensed:

            ApplyFace(condense, pWindow, pData, cCondensed);

            break;

        case cExtended:

            ApplyFace(extend, pWindow, pData, cExtended);

            break;

        // SUPPORTED SIZES

        case cSize9:

            anErr = ApplySize(9, pWindow, pData, cSize9);

            break;

        case cSize10:

            anErr = ApplySize(10, pWindow, pData, cSize10);

            break;

        case cSize12:

            anErr = ApplySize(12, pWindow, pData, cSize12);

            break;

        case cSize14:

            anErr = ApplySize(14, pWindow, pData, cSize14);

            break;

        case cSize18:

            anErr = ApplySize(18, pWindow, pData, cSize18);

            break;

        case cSize24:

            anErr = ApplySize(24, pWindow, pData, cSize24);

            break;

        case cSize36:

            anErr = ApplySize(36, pWindow, pData, cSize36);

            break;

        // SUPPORTED SOUND COMMANDS

        case cRecord:

            {

            Handle  tempHandle;

            // allocate our prefered buffer if we can, but if we can't

            // make sure that at least a minimum amount of RAM is around

            // before recording.

            tempHandle = NewHandle(kPrefBufferSize);

            anErr = MemError();

            if (anErr != noErr)

                {

                tempHandle = NewHandle(kMinBufferSize);

                anErr = MemError();

                DisposeHandle(tempHandle);

                tempHandle = nil;

                }

            // if the preflight goes okay, do the record

            if (anErr == noErr)

                {

                Point   where = {50, 100};

                anErr = SndRecord(nil, where, siGoodQuality, (SndListHandle*) &tempHandle);

                if (anErr == noErr)

                    {

                    DisposeHandle(((TextDataPtr) pData)->soundHandle);

                    ((TextDataPtr) pData)->soundHandle = tempHandle;

                    pData->changed = true;

                    }

                else

                    DisposeHandle(tempHandle);

                if (anErr == userCanceledErr)

                    anErr = noErr;

                }

            }

            break;

        case cPlay:

            if (((TextDataPtr) pData)->soundHandle)

                (void) SndPlay(nil, (SndListHandle) ((TextDataPtr) pData)->soundHandle, false);

            break;

        case cErase:

            DisposeHandle(((TextDataPtr) pData)->soundHandle);

            ((TextDataPtr) pData)->soundHandle = nil;

            pData->changed = true;

            break;

        case cSpeak:

            DisposeOfSpeech(false);

            if (gSpeechChannel == nil)

                anErr = NewSpeechChannel( &gCurrentVoice, &gSpeechChannel );

            if ( anErr == noErr )

                {

                short   textLength, textStart;

                // determine which text to speak

                if ( (**((TextDataPtr) pData)->hTE).selEnd > (**((TextDataPtr) pData)->hTE).selStart )  // If there is a selection.

                    {

                    textLength = (**((TextDataPtr) pData)->hTE).selEnd - (**((TextDataPtr) pData)->hTE).selStart;

                    textStart = (**((TextDataPtr) pData)->hTE).selStart;

                    }

                else                                            // No text selected.

                    {

                    textLength = (**((TextDataPtr) pData)->hTE).teLength;

                    textStart = 0;

                    }

                gSpeakPtr = NewPtr(textLength);

                anErr = MemError();

                if (anErr == noErr)

                    {

                    BlockMoveData( *((**((TextDataPtr) pData)->hTE).hText) + textStart, gSpeakPtr, (Size) textLength );

                    anErr = SpeakText( gSpeechChannel, gSpeakPtr, textLength );

                    }

                }

            break;

        case cStopSpeaking:

            DisposeOfSpeech(true);

            break;

        case cSelectVoiceSubMenu:

                {

                VoiceSpec   newSpec;

                short       i, menuIndex;

                Str255      itemText;

                short       theVoiceCount;

                MenuHandle  menu = GetMenuHandle(mVoices);

                // in order to change voices, we need to ditch the speaking

                DisposeOfSpeech(true);

                // get the name of the selected voice               

                menuIndex = menuResult & 0xFFFF;

                GetMenuItemText(menu, menuIndex, itemText);

                if (CountVoices( &theVoiceCount ) == noErr)

                    {

                    VoiceDescription    description;        // Info about a voice.

                    for (i = 1; i <= theVoiceCount; ++i)

                        {

                        if ( (GetIndVoice( i, &newSpec ) == noErr)  &&

                             (GetVoiceDescription( &newSpec, &description, sizeof(description) ) == noErr ) )

                            {

                            if (IUCompString( itemText, description.name ) == 0)

                                break;

                            }

                        }

                    }

                gCurrentVoice = newSpec;

                for (i = CountMItems(menu); i >= 1; --i)

                    CheckItem(menu, i, (menuIndex == i));

                }

            break;

        case cSelectContents:

                {

                Str255  searchStr;

                short   menuIndex;

                long    newStart, newEnd;

                menuIndex = menuResult & 0xFFFF;

                // get the search string for this menu item

                anErr = TextGetContentsListItem(pData, menuIndex, nil, searchStr, nil);

                if (anErr == noErr)

                    {

                    if (PerformSearch(

                        (**((TextDataPtr) pData)->hTE).hText,

                        0,          // start at beginning of text

                        searchStr,

                        false,      // not case sensitive

                        false,      // forwards

                        false,      // wrap

                        &newStart, 

                        &newEnd))

                        {

                        // <7>

                        short   amount;