/*

**  File:       SimpleText.c

**

**  Contains:   SimpleText - a simple document editing application for shipping

**                           with system software.

**

**  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 <ImageCompression.h>   // for CustomGetFilePreview

#include <Threads.h>

#define CompilingMain=1

#include "SimpleText.h"

#include "Clipboard.h"

#include "ExtendPrintRecord.h"

#include "ScriptablePrinting.h"

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

// FORWARD DECLARES

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

OSErr   DoActivate(WindowRef pWindow, Boolean activating);

OSErr   DoCommand(WindowRef pWindow, short commandID, long menuResult);

OSErr   DoKeyEvent(WindowRef pWindow, EventRecord * pEvent, Boolean processPageControls);

Boolean CommandToIDs(short commandID, short * menuID, short *itemID);

void    AdjustMenus(WindowRef pWindow, Boolean editDialogs, Boolean forceTitlesOn);

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

// GLOBAL VARIABLES

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

EventRecord         gEvent;                 // currently pending event

Boolean             gAllDone;               // true if the application is the in process of terminating

MachineInfoRec      gMachineInfo;           // info about abilities and options installed on this machine

short               gApplicationResFile;    // resource fork of application

RgnHandle           gCursorRgn;             // region to control the cursor apearence

AGRefNum            gAGRefNum = -1;         // AppleGuide database which is open

FSSpec              gAGSpec;                // where to find our database

AGCoachRefNum       gAGCoachRefNum = -1;    // coach handler refNum

FontMappingHandle   gFontMappingList = nil; // list of font mappings

ThreadID            gFontThread;            // thread that builds font menu

ThreadID            gAGThread;              // thread that looks for AppleGuide database

ThreadID            gStarterThread;         // starts our other threads for us

Boolean             gDontYield;             // whether our threads should yield

void*               gThreadResults;         // scratch space for thread results

// These variables are for the find/replace commands

Str255          gFindString = "\p", gReplaceString = "\p";

Boolean         gWrapAround = false, gCaseSensitive = false;

// Metrowerks MWCRuntime.lib defines qd for us on PPC, and their

// __runtime module does under the 68K case. OTOH, neither SC nor

// MrC give us qd for free, so we need it there. I'm still not

// certain which way to go for the ThinkC or Symantec PPC case.

#if !defined(__MWERKS__)

// QuickDraw globals

QDGlobals       qd;

#endif

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

#pragma segment Utility

static pascal Boolean AlertFilter(DialogRef theDialog, EventRecord *theEvent, short *itemHit)

{

    if (theEvent->what == activateEvt && (DialogRef) theEvent->message == theDialog)

        {

        SetDialogDefaultItem(theDialog, 1);

        }

    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;

} // AlertFilter

void ConductErrorDialog(OSErr error, short commandID, short alertType)

{

    long        foundError;         // The error, converted to a number

    short       stringIndex;        // Index into the strings

    Str255      errorText;          // the error in a string format

    // Start with no error so far

    foundError = 0;

    // Start with the first string

    stringIndex = 1;

    // Loop until we find an error string

    errorText[0] = 0;

    do

        {

        // Get the string, and convert it to a number

        GetIndString(errorText, kErrorBaseID + commandID, stringIndex);

        if (errorText[0] == 0)

            break;

        StringToNum(errorText, &foundError);

        // If we reach the last string, or we match the error code

        if ((foundError == 0) ||

            (foundError == error))

            {

            // Get the text string for this error

            GetIndString(errorText, kErrorBaseID + commandID, stringIndex+1);

            }

        else

            {

            // Otherwise, make us continue until we get a string

            errorText[0] = 0;

            }

        // Advance so we get the next string number

        stringIndex += 2;

        } while (errorText[0] == 0);                // errorText[0] == 0

    if (errorText[0] != 0)

        {

        DialogRef   dPtr;

        short       hit;

        SetCursor(&qd.arrow);

        ParamText(errorText, "\p", "\p", "\p");

        #if !GENERATINGPOWERPC

            if (gMachineInfo.theEnvirons.systemVersion < 0x0700)

                {

                short ** hDialog;

                hDialog = (short**) GetResource('DLOG', kErrorBaseID + alertType);

                (*hDialog)[4] = dBoxProc;

                dPtr = GetNewDialog(kErrorBaseID + alertType, nil, (WindowRef)-1);

                do

                    {

                    ModalDialog(nil, &hit);

                    } while (hit != ok);

                DisposeDialog(dPtr);

                }

            else

                {

                dPtr = GetNewDialog(kErrorBaseID + alertType, nil, (WindowRef)-1);

                SetDialogDefaultItem(dPtr, ok);

                BeginMovableModal();

                do

                    {

                    MovableModalDialog(nil, &hit);

                    } while (hit != ok);

                DisposeDialog(dPtr);

                EndMovableModal();

                }

        #else

            dPtr = GetNewDialog(kErrorBaseID + alertType, nil, (WindowRef)-1);

            SetDialogDefaultItem(dPtr, ok);

            BeginMovableModal();

            do

                {

                MovableModalDialog(nil, &hit);

                } while (hit != ok);

            DisposeDialog(dPtr);

            EndMovableModal();

        #endif

        }

} // ConductErrorDialog

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

#pragma segment Utility

static void MovableModalMenus(DialogRef dPtr, short *pItem, long menuResult)

{

    short   iCut, iCopy, iClear, iPaste;

    short   editMenu;

    short   menuItem = menuResult & 0xFFFF;

    // find out where edit menus are

    CommandToIDs(cCut, &editMenu, &iCut);

    CommandToIDs(cCopy, &editMenu, &iCopy);

    CommandToIDs(cClear, &editMenu, &iClear);

    CommandToIDs(cPaste, &editMenu, &iPaste);

    HiliteMenu(0);

    switch (menuResult >> 16)

        {

        case mApple:

            {

            Str255  tempString;

            GetMenuItemText(GetMenuHandle(menuResult>>16), menuItem, tempString);

            OpenDeskAcc(tempString);

            }

            break;

        case mEdit:

            {

            short   type;

            Handle  item;

            Rect    box;

            short   editField = GetDialogKeyboardFocusItem(dPtr);

            // return typed item, if it isn't disabled

            GetDialogItem(dPtr, editField, &type, &item, &box);

            if ((type & itemDisable) == 0)

                *pItem = editField;

            if (menuItem == iCut)

                {

                DialogCut(dPtr);

                ZeroScrap();

                TEToScrap();

                }

            if (menuItem == iCopy)

                {

                DialogCopy(dPtr);

                ZeroScrap();

                TEToScrap();

                }

            if (menuItem == iClear)

                DialogDelete(dPtr);

            if (menuItem == iPaste)

                DialogPaste(dPtr);

            }

            break;

        }

} // MovableModalMenus

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

#pragma segment Utility

void MovableModalDialog(ModalFilterProcPtr filterProc, short *pItem)

/*

    Call this as you would ModalDialog, when the dialog is moveable

    modal.

    However, first call BeginMovableModal, and afterwards (after

    disposing of dialog) call EndMovableModal.

*/

{

    GrafPtr     curPort;

    DialogRef   dPtr = FrontWindow();

    *pItem = 0; 

    if (dPtr)

        {

        GetPort(&curPort);

        SetPort(dPtr);

        do

            {

            WaitNextEvent(mDownMask + mUpMask + keyDownMask + keyUpMask + autoKeyMask + updateMask + activMask + osMask,

                            &gEvent, 0, nil);

            // call the filter proc

            if ( (filterProc) && ((*filterProc) (dPtr, &gEvent, pItem)) )

                break;

            // call the basic filtering

            if (StdFilterProc(dPtr, &gEvent, pItem))

                break;

            // handle keyboard

            if ((gEvent.what == keyDown) && (gEvent.modifiers & cmdKey))

                {

                MovableModalMenus(dPtr, pItem, MenuKey(gEvent.message & charCodeMask));

                break;

                }

            // handle clicks and drags

            if (gEvent.what == mouseDown)

                {

                WindowRef   whichWindow;

                short       part = FindWindow(gEvent.where, &whichWindow);

                // menu bar events

                if (part == inMenuBar)

                    {

                    MovableModalMenus(dPtr, pItem, MenuSelect(gEvent.where));

                    break;

                    }

                // check for outside of our window

                if (!PtInRgn(gEvent.where, ((WindowPeek)dPtr)->strucRgn))

                    {

                    SysBeep(1);

                    gEvent.what = nullEvent;

                    }

                // drag the window around

                if ( (part == inDrag) && (whichWindow == dPtr) )

                    {

                    Rect    tempRect = (**GetGrayRgn()).rgnBBox;

                    DragWindow(GetDialogWindow(dPtr), gEvent.where, &tempRect);

                    gEvent.what = nullEvent;

                    }

                }

            // check with standard dialog stuff 

            {

            DialogRef   tempDialog;

            if ( IsDialogEvent(&gEvent) && DialogSelect(&gEvent, &tempDialog, pItem) )

                break;

            }

            // handle updates

            if (gEvent.what == updateEvt)

                {

                HandleEvent(&gEvent);

                break;

                }

            } while (true);

        SetPort(curPort);

        }

} // MovableModalDialog

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

#pragma segment Utility

void BeginMovableModal(void)

{

    DialogRef   dPtr = FrontWindow();

    WindowRef   nextWindow = GetNextWindow(dPtr);

    if (nextWindow)

        DoActivate(nextWindow, false);

    AdjustMenus(GetDialogWindow(dPtr), (GetDialogKeyboardFocusItem(dPtr) > 0), false);

} // BeginMovableModal

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

#pragma segment Utility

void EndMovableModal(void)

{

    WindowRef   nextWindow = FrontWindow();

    AdjustMenus(nextWindow, true, false);

    if (nextWindow)

        DoActivate(nextWindow, true);

} // EndMovableModal

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

#pragma segment Utility

short ConductFindOrReplaceDialog(short dialogID)

{

    DialogRef   dPtr;

    short       hit;

    dPtr = GetNewDialog(dialogID, nil, (WindowRef)-1);

    if (dPtr)

        {

        short   kind;

        Rect    box;

        Handle  item;

        // standard default behavior

        SetDialogDefaultItem(dPtr, ok);

        SetDialogCancelItem (dPtr, cancel);

        SetDialogTracksCursor(dPtr, true);

        // Find string

        GetDialogItem(dPtr, iFindEdit, &kind, &item, &box);

        SetDialogItemText(item, gFindString);

        // check boxes

        GetDialogItem(dPtr, iCaseSensitive, &kind, &item, &box);

        SetControlValue((ControlRef)item, gCaseSensitive);

        GetDialogItem(dPtr, iWrapAround, &kind, &item, &box);

        SetControlValue((ControlRef)item, gWrapAround);

        if (dialogID == kReplaceWindowID)

            {

            // Replace string

            GetDialogItem(dPtr, iReplaceEdit, &kind, &item, &box);

            SetDialogItemText(item, gReplaceString);

            }

        // select the search text by default

        SelectDialogItemText(dPtr, iFindEdit, 0, 32767);

        // and away we go!

        ShowWindow(GetDialogWindow(dPtr));

        BeginMovableModal();

        do

            {

            MovableModalDialog(nil, &hit);

            switch (hit)

                {

                case iCaseSensitive:

                case iWrapAround:

                    GetDialogItem(dPtr, hit, &kind, &item, &box);

                    SetControlValue((ControlRef)item, 1-GetControlValue((ControlRef)item));

                    break;

                }

            } while ( (hit != ok) && (hit != cancel) && (hit != iReplaceAll) );

        if (hit != cancel)

            {

            // Find string

            GetDialogItem(dPtr, iFindEdit, &kind, &item, &box);

            GetDialogItemText(item, gFindString);

            // check boxes

            GetDialogItem(dPtr, iCaseSensitive, &kind, &item, &box);

            gCaseSensitive = GetControlValue((ControlRef)item);

            GetDialogItem(dPtr, iWrapAround, &kind, &item, &box);

            gWrapAround = GetControlValue((ControlRef)item);

            if (dialogID == kReplaceWindowID)

                {

                // Replace string

                GetDialogItem(dPtr, iReplaceEdit, &kind, &item, &box);

                GetDialogItemText(item, gReplaceString);

                }

            }

        DisposeDialog(dPtr);

        EndMovableModal();

        }

    return(hit);

} // ConductFindOrReplaceDialog

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

#pragma segment Utility

void SetWatchCursor(void)

{

    CursHandle  theWatch;

    theWatch = GetCursor(watchCursor);

    if (theWatch)

        {

        char    oldState;

        oldState = HGetState((Handle) theWatch);

        HLock((Handle) theWatch);

        SetCursor(*theWatch);

        HSetState((Handle) theWatch, oldState);

        }

} // SetWatchCursor

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

#pragma segment Utility

void LongRectToRect(LongRect* longRect, Rect *rect)

{

    rect->top       = longRect->top;

    rect->left      = longRect->left;

    rect->bottom    = longRect->bottom;

    rect->right     = longRect->right;

} // LongRectToRect

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

#pragma segment Utility

void RectToLongRect(Rect *rect, LongRect *longRect)

{

    longRect->top       = rect->top;

    longRect->left      = rect->left;

    longRect->bottom    = rect->bottom;

    longRect->right     = rect->right;

} // RectToLongRect

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

#pragma segment Utility

#ifndef ff

#define ff(x) (x << 16)

#endif

void GetPICTRectangleAt72dpi(PicHandle hPicture, Rect *pictureRect)

{

    typedef struct FixedRect {

        Fixed left;

        Fixed top;

        Fixed right;

        Fixed bottom;

    } FixedRect;

    typedef struct {

        Picture             pictInfo;

        unsigned short      versionOp;      // 0x1101

        Byte                opCodes[1];

    } PICTHeaderVer1;

    typedef struct {

        Picture         pictInfo;

        unsigned short  versionOp;      // 0x0011

        unsigned short  versionOp2;     // 0x02ff

        unsigned short  headerOp;       // 0x0c00

        unsigned short  version;        // 0xffff

        unsigned short  version2;       // 0xffff

        FixedRect       pictBounds;

        unsigned long   reserved;

        unsigned short  opCodes[1];

    } PICTHeaderVer2;

    typedef struct {

        Picture         pictInfo;

        unsigned short  versionOp;      // 0x0011

        unsigned short  versionOp2;     // 0x02ff

        unsigned short  headerOp;       // 0x0c00

        unsigned short  version;        // 0xfffe

        unsigned short  reserved;       // 0x0000

        Fixed           hRes;

        Fixed           vRes;

        Rect            pictBounds;

        unsigned long   reserved2;

        unsigned short  opCodes[1];

    } PICTHeaderVer2Ext;

    const Fixed seventyTwo = 0x480000;

    Fixed           hRes, vRes;

    PICTHeaderVer1* pPict = (PICTHeaderVer1*) *hPicture;

    hRes = vRes = seventyTwo;       // assume 72 dpi, Fixed

    if (pPict->versionOp == 0x0011) 

        {   

        // Version 2 PICT

        PICTHeaderVer2* pPict2 = (PICTHeaderVer2*) pPict;

        if (pPict2->version == 0xfffe) 

            {   

            // Extended Version 2

            PICTHeaderVer2Ext* pPict2ext = (PICTHeaderVer2Ext*) pPict;

            hRes = pPict2ext->hRes;

            vRes = pPict2ext->vRes;

            }

        }

    hRes = FixDiv(hRes, seventyTwo);

    vRes = FixDiv(vRes, seventyTwo);

    pictureRect->left   = Fix2Long(FixDiv( ff((**hPicture).picFrame.left),      hRes ));

    pictureRect->right  = Fix2Long(FixDiv( ff((**hPicture).picFrame.right),     hRes ));

    pictureRect->top    = Fix2Long(FixDiv( ff((**hPicture).picFrame.top),       vRes ));

    pictureRect->bottom = Fix2Long(FixDiv( ff((**hPicture).picFrame.bottom),    vRes ));

} // GetPICTRectangleAt72dpi

#undef ff

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

#pragma segment Utility

static WindowDataPtr    GetWindowInfo(WindowRef pWindow)

{

    WindowDataPtr result = nil;

    if  (

        (pWindow) &&

        (GetWindowKind(pWindow) == userKind)

        )

        result = (WindowDataPtr) GetWRefCon(pWindow);

    return result;

} // GetWindowInfo

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

#pragma segment Utility

static short ZeroStringSub(Str255 destString, Str255 subStr)

    // returns number of substitutions performed

{

    OSErr   anErr;

    Handle  destHandle = nil;

    Handle  subHandle = nil;

    short   count = 0;

    anErr = PtrToHand(&destString[1], &destHandle, destString[0]);

    if (anErr == noErr)

        {       

        anErr = PtrToHand(&subStr[1], &subHandle, subStr[0]);

        if (anErr == noErr)

            {

            count = ReplaceText(destHandle, subHandle, "\p^0");     // error or # of substitutions

            destString[0] = GetHandleSize(destHandle);

            BlockMoveData(*destHandle, &destString[1], destString[0]);

            }

        }

    DisposeHandle(destHandle);

    DisposeHandle(subHandle);

    if (count < 0)

        count = 0;      // change error code into count = 0 substitutions

    return count;

} // ZeroStringSub

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

// SEARCH/REPLACE UTILITY FUNCTIONS

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

static Boolean IsThisTheString(

            Ptr p,                      // pointer to check

            Str255 searchString,        // string to check for

            Boolean isCaseSensitive)    // case sensitive check or not

/*

    Returns true if the supplied string is at the specified offset.

    Otherwise returns false.

*/

{

    Boolean returnValue = false;

    if (isCaseSensitive)

        returnValue = ( IUMagString(p, &searchString[1], searchString[0], searchString[0]) == 0 );

    else

        returnValue = ( IUMagIDString(p, &searchString[1], searchString[0], searchString[0]) == 0 );

    return(returnValue);

} // IsThisTheString

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

Boolean PerformSearch(

        Handle  h,                  // handle to search

        long start,                 // offset to begin with

        Str255 searchString,        // string to search for

        Boolean isCaseSensitive,    // case sensitive search

        Boolean isBackwards,        // search backwards from starting point

        Boolean isWraparound,       // wrap search around from end->begining

        long * pNewStart,           // returned new selection start

        long * pNewEnd)             // returned new selection end

/*

    Performs a search on the supplied handle, starting at the provided

    offset.  Returns the new selection start and end values, and true

    if the search is successful.  Otherwise it returns false.

*/

{

    char    flags;

    Ptr     startPtr;

    Ptr     endPtr;

    Ptr     searchPtr;

    Boolean foundIt = false;

    flags = HGetState(h);

    HLock(h);

    // back up one when searching backwards, or we'll hit every time on the current

    // character

    if (isBackwards)

        {

        if (start != 0)

            {

            --start;

            }

        else

            {

            if (isWraparound)

                start = GetHandleSize(h);

            else

                return(false);

            }

        }

    // determine the bounds of the searching

    startPtr = (*h) + start;

    if ( isWraparound )

        {

        if (isBackwards)

            {

            // go backwards until just after the start, or begining of

            // document is start is the end

            if (start == GetHandleSize(h))

                endPtr = *h;

            else

                endPtr = startPtr + 1;

            }

        else

            {

            // go forwards until just before the start, or to the end

            // of the document is the start is already the begining

            if (start == 0)

                endPtr = *h + GetHandleSize(h);

            else

                endPtr = startPtr - 1;

            }

        }

    else

        {

        if (isBackwards)

            {

            // go back until hit begining of document

            endPtr = *h-1;  

            }

        else

            {

            // go forward until hit end of document

            endPtr = *h + GetHandleSize(h);

            }

        }

    searchPtr = startPtr;

    while (searchPtr != endPtr)

        {

        if (IsThisTheString(searchPtr, searchString, isCaseSensitive))

            {

            foundIt = true;

            *pNewStart = searchPtr - *h;

            *pNewEnd = *pNewStart + searchString[0];

            break;

            }

        if (isBackwards)

            --searchPtr;

        else

            ++searchPtr;

        if (isWraparound)

            {

            if (searchPtr < *h)

                searchPtr = *h + GetHandleSize(h);

            if (searchPtr > *h + GetHandleSize(h))

                searchPtr = *h;

            }

        }

    HSetState(h, flags);

    return(foundIt);

} // PerformSearch

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

// SELECTION UTILITY ROUTINES

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

void DrawSelection(WindowDataPtr pData, Rect *pSelection, short * pPhase, Boolean bumpPhase)

{

    if  (!EmptyRect(pSelection) ) 

        {

        RgnHandle   oldClip = NewRgn();

        Pattern     aPattern;

        Rect        newClip;

        if  ( 

            (bumpPhase) && 

            (MOVESELECTION(TickCount()) ) 

            )

            {

            if ((++(*pPhase)) > 7 )

                *pPhase = 1;

            }

        // setup for drawing in this window

        SetPort((GrafPtr) pData);

        GetClip(oldClip);

        PenMode(notPatXor);

        // offset the draw area (SetOrigin a must to preserve pattern appearence)

        // and the clip area to avoid stepping on the scroll bars

        SetOrigin(GetControlValue(pData->hScroll), GetControlValue(pData->vScroll));

        newClip = pData->contentRect;

        OffsetRect(&newClip, GetControlValue(pData->hScroll), GetControlValue(pData->vScroll));

        ClipRect(&newClip);

        // do the draw

        GetIndPattern(&aPattern, kPatternListID, (*pPhase)+1);

        PenPat(&aPattern);

        FrameRect(pSelection);

        SetOrigin(0, 0);

        // restore the old port settings

        SetClip(oldClip);

        DisposeRgn(oldClip);

        PenNormal();

        }

} // DrawSelection

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

OSErr SelectContents(WindowRef pWindow, WindowDataPtr pData, EventRecord *pEvent, Rect *pSelection, Rect *pContent, short *pPhase)

{

    OSErr           anErr = noErr;

    Point           clickPoint = pEvent->where;

    Point           currentPoint;

    Boolean         didJustScroll;

    ControlRef      theControl;

    GlobalToLocal(&clickPoint);

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

        {

        // move the click point into the proper range

        clickPoint.h += GetControlValue(pData->hScroll);

        clickPoint.v += GetControlValue(pData->vScroll);

        // if the shift key is held down then the selection starts from

        // a preexisting point such that we are doing an expand/contract

        // of the original selection

        if (pEvent->modifiers & shiftKey)

            {

            if (clickPoint.h < pSelection->right)

                clickPoint.h = pSelection->right;

            else

                clickPoint.h = pSelection->left;

            if (clickPoint.v < pSelection->bottom)

                clickPoint.v = pSelection->bottom;

            else

                clickPoint.v = pSelection->top;

            }

        while (StillDown())

            {                   

            // get the current mouse 

            GetMouse(&currentPoint);

            didJustScroll = false;

            // scroll contents if needed

            {

            short   deltaH = 0;

            short   deltaV = 0;

            if (currentPoint.h < 0)

                deltaH = pData->hScrollAmount;

            if (currentPoint.h > qd.thePort->portRect.right)

                deltaH = -pData->hScrollAmount;

            if (currentPoint.v < 0)

                deltaV = pData->vScrollAmount;

            if (currentPoint.v > qd.thePort->portRect.bottom)

                deltaV = -pData->vScrollAmount;

            if ( (deltaH != 0) || (deltaV != 0) )

                {               

                if (deltaH)

                    SetControlAndClipAmount(pData->hScroll, &deltaH);

                if (deltaV)

                    SetControlAndClipAmount(pData->vScroll, &deltaV);

                DoScrollContent(pWindow, pData, deltaH, deltaV);

                didJustScroll = true;

                }

            }

            // map mouse into proper range

            currentPoint.h += GetControlValue(pData->hScroll);

            currentPoint.v += GetControlValue(pData->vScroll);

            // clip to the document size

            if (currentPoint.h < 0)

                currentPoint.h = 0;

            if (currentPoint.v < 0)

                currentPoint.v = 0;

            if (currentPoint.h > pContent->right)

                currentPoint.h = pContent->right;

            if (currentPoint.v > pContent->bottom)

                currentPoint.v = pContent->bottom;

            // draw the new selection if it is time or we are about to 

            // exit this loop

            if ((MOVESELECTION(TickCount())) || (!Button()) || (didJustScroll) )

                {

                // first, erase any old selection we might have had

                DrawSelection(pData, pSelection, pPhase, false);

                // make a rectangle out of the two points

                pSelection->left    = Min(currentPoint.h, clickPoint.h);

                pSelection->right   = Max(currentPoint.h, clickPoint.h);

                pSelection->top     = Min(currentPoint.v, clickPoint.v);

                pSelection->bottom  = Max(currentPoint.v, clickPoint.v);

                // draw the new selection

                DrawSelection(pData, pSelection, pPhase, true);

                }

            }

        // we handled the selection

        anErr = eActionAlreadyHandled;

        }

    return(anErr);

} // SelectContents

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

void DragAndDropArea(WindowRef pWindow, WindowDataPtr pData, EventRecord* event, Rect *pFrameRect)

{

    RgnHandle       hilightRgn;

    Rect            r;

    DragReference   theDrag;

    OSErr           anErr = noErr;

    if (NewDrag(&theDrag) == noErr)

        {

        if (pData->pDragAddFlavors)

            anErr = (*(pData->pDragAddFlavors)) (pWindow, pData, theDrag);

        if (anErr == noErr)

            {

            Rect    globalRect = *pFrameRect;

            hilightRgn = NewRgn();  

            LocalToGlobal(&TopLeft(globalRect));

            LocalToGlobal(&BotRight(globalRect));

            RectRgn(hilightRgn, &globalRect);

            SetDragItemBounds(theDrag, 1, &r);

            // turn the region from a fill into a frame

            {   

                RgnHandle tempRgn = NewRgn();

                CopyRgn(hilightRgn, tempRgn);

                InsetRgn(tempRgn, 1, 1);

                DiffRgn(hilightRgn, tempRgn, hilightRgn);

                DisposeRgn(tempRgn);

            }

            TrackDrag(theDrag, event, hilightRgn);

            DisposeDrag(theDrag);

            DisposeRgn(hilightRgn);

            }

        }

} // DragAndDropArea

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

// WINDOW UTILITY ROUTINES

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

#pragma segment Main

static void CalculateGrowIcon(WindowDataPtr pData, Rect * location)

{

    if (pData->vScroll)

        location->top = (**pData->vScroll).contrlRect.bottom;

    else

        {

        if (pData->hScroll)

            location->top = (**pData->hScroll).contrlRect.top;

        else

            location->top = pData->theWindow.port.portRect.bottom - 15;

        }

    if (pData->hScroll)

        location->left = (**pData->hScroll).contrlRect.right;

    else

        {

        if (pData->vScroll)

            location->left = (**pData->vScroll).contrlRect.left;

        else

            location->left = pData->theWindow.port.portRect.right - 15;

        }

    location->right = location->left + 16;

    location->bottom = location->top + 16;

} // CalculateGrowIcon

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

#pragma segment Main

OSErr   AdjustScrollBars(WindowRef pWindow,

    Boolean moveControls,               // might the controls have moved?

    Boolean didResize,                  // did we just resize the window?

    Boolean *needInvalidate)            // does the caller need to invalidate contents as a result?

{

    OSErr           anErr = noErr;

    LongRect        docRect;

    WindowDataPtr   pData = GetWindowInfo(pWindow);

    Rect            growIconRect;

    if (needInvalidate)

        *needInvalidate = false;

    if (pData)

        {

        short   oldHMax, oldVMax;

        short   oldHValue, oldVValue;

        // cache current values, we'll force an update if we needed to change em!

        if (pData->hScroll)

            {

            oldHMax = GetControlMaximum(pData->hScroll);

            oldHValue = GetControlValue(pData->hScroll);

            }

        if (pData->vScroll)

            {

            oldVMax = GetControlMaximum(pData->vScroll);

            oldVValue = GetControlValue(pData->vScroll);

            }

        // if we have a grow box but not all controls we have to invalidate the grow bar areas

        // by caclulating them

        if ( (didResize) && (pData->hasGrow) )

            {

            // if we regrow without any scroll bars, we need to update the content area

            if ( (needInvalidate) && (pData->hScroll == nil) && (pData->vScroll == nil) )

                *needInvalidate = true;

            // invalidate old grow bar areas

            if (pData->vScroll == nil)

                {

                growIconRect = GetWindowPort(pWindow)->portRect;

                growIconRect.left = pData->contentRect.right;

                InvalRect(&growIconRect);

                }

            if (pData->hScroll == nil)

                {

                growIconRect = GetWindowPort(pWindow)->portRect;

                growIconRect.top = pData->contentRect.bottom;

                InvalRect(&growIconRect);

                }

            // invalidate new grow bar areas

            if (pData->vScroll == nil)

                {

                growIconRect = GetWindowPort(pWindow)->portRect;

                growIconRect.left = growIconRect.right - kScrollBarSize;

                InvalRect(&growIconRect);

                }

            if (pData->hScroll == nil)

                {

                growIconRect = GetWindowPort(pWindow)->portRect;

                growIconRect.top = growIconRect.bottom - kScrollBarSize;

                InvalRect(&growIconRect);

                }

            }

        // if the controls need moving, recalculate the visible area

        if (moveControls)

            {

            pData->contentRect = GetWindowPort(pWindow)->portRect;

            if ((pData->hScroll) || (pData->hasGrow) )

                pData->contentRect.bottom -= kScrollBarSize;

            if ((pData->vScroll) || (pData->hasGrow) )

                pData->contentRect.right -= kScrollBarSize;

            }

        // before doing anything, make the controls invisible

        if (pData->hScroll)

            (**pData->hScroll).contrlVis = 0;   

        if (pData->vScroll)

            (**pData->vScroll).contrlVis = 0;

        // based on document and visiable area, adjust possible control values

        if ( (pData->pGetDocumentRect) && ((pData->hScroll) || (pData->vScroll)) )

            {

            // let the object calc the size and content if it wishes to

            anErr = (*(pData->pGetDocumentRect)) (pWindow, pData, &docRect, false);

            if (anErr == noErr)

                {

                short   amountOver;

                short   newMax;

                amountOver = (docRect.right - docRect.left) - (pData->contentRect.right - pData->contentRect.left);

                if  (

                    (pData->hScroll) &&

                    (amountOver > 0)

                    )

                    newMax = amountOver;

                else

                    newMax = 0;

                if (pData->hScroll)

                    {

                    if (GetControlValue(pData->hScroll) > newMax)

                        {

                        if (needInvalidate)

                            *needInvalidate = true;

                        }

                    SetControlMaximum(pData->hScroll, newMax);

                    }

                amountOver = (docRect.bottom - docRect.top) - (pData->contentRect.bottom - pData->contentRect.top);

                if  (

                    (pData->vScroll) &&

                    (amountOver > 0)

                    )

                    newMax = amountOver;

                else

                    newMax = 0;

                if (pData->vScroll)

                    {

                    if (GetControlValue(pData->vScroll) > newMax)

                        {

                        if (needInvalidate)

                            *needInvalidate = true;

                        }

                    SetControlMaximum(pData->vScroll, newMax);

                    }

                }

            }

        // then, if the controls need moving, we move them and inval the old

        // and new locations

        if (moveControls)

            {

            // if we have grow box we invalidate the old grow location

            if ( pData->hasGrow) 

                {

                CalculateGrowIcon(pData, &growIconRect);

                InvalRect(&growIconRect);

                }

            if (pData->hScroll)

                {

                short   widthAdjust;

                if ((pData->vScroll) || (pData->hasGrow))

                    widthAdjust = -kGrowScrollAdjust;

                else

                    widthAdjust = -1;

                growIconRect = (**pData->hScroll).contrlRect;

                InvalRect(&growIconRect);

                MoveControl(pData->hScroll, pData->hScrollOffset-1, GetWindowPort(pWindow)->portRect.bottom - kScrollBarSize);

                SizeControl(pData->hScroll, (GetWindowPort(pWindow)->portRect.right - 

                            GetWindowPort(pWindow)->portRect.left) + widthAdjust - pData->hScrollOffset,

                            16);

                growIconRect = (**pData->hScroll).contrlRect;

                InvalRect(&growIconRect);

                }

            if (pData->vScroll)

                {

                short   heightAdjust;

                if ((pData->hScroll) || (pData->hasGrow))

                    heightAdjust = -kGrowScrollAdjust;

                else

                    heightAdjust = -1;

                growIconRect = (**pData->vScroll).contrlRect;

                InvalRect(&growIconRect);

                MoveControl(pData->vScroll, GetWindowPort(pWindow)->portRect.right - kScrollBarSize, pData->vScrollOffset-1);

                SizeControl(pData->vScroll, 16,

                            (GetWindowPort(pWindow)->portRect.bottom - 

                            GetWindowPort(pWindow)->portRect.top) + heightAdjust - pData->vScrollOffset);

                growIconRect = (**pData->vScroll).contrlRect;

                InvalRect(&growIconRect);

                }

            // if we have scroll bars, update the grow icon

            if ( pData->hasGrow )

                {

                CalculateGrowIcon(pData, &growIconRect);

                InvalRect(&growIconRect);

                }

            }

        // let the document adjust anything it needs to

        if (pData->pAdjustSize)

            anErr = (*(pData->pAdjustSize)) (pWindow, pData, &didResize);

        if ((didResize) && (needInvalidate))

            *needInvalidate = true;

        if ( ((WindowPeek) pWindow)->hilited )

            {

            // after doing something, make the controls visible

            if (pData->hScroll)

                {

                if ((oldHMax != GetControlMaximum(pData->hScroll)) || (oldHValue != GetControlValue(pData->hScroll)) )

                    ShowControl(pData->hScroll);

                else

                    (**pData->hScroll).contrlVis = 0xFF;    

                }

            if (pData->vScroll)

                {

                if ((oldVMax != GetControlMaximum(pData->vScroll)) || (oldVValue != GetControlValue(pData->vScroll)) )

                    ShowControl(pData->vScroll);

                else

                    (**pData->vScroll).contrlVis = 0xFF;

                }

            }

        }

    return anErr;

} // AdjustScrollBars

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

// MENU UTILITY ROUTINES

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

#pragma segment Main

Boolean CommandToIDs(short commandID, short * menuID, short *itemID)

{

    short   ** commandHandle;

    short   whichMenu;

    short   oldResFile = CurResFile();

    Boolean returnValue = false;

    UseResFile(gApplicationResFile);

    for (whichMenu = mApple; whichMenu <= mLastMenu; whichMenu++)

        {

        commandHandle = (short**) Get1Resource('MCMD', whichMenu);

        if (commandHandle)

            {

            short   * pCommands = *commandHandle;

            short   commandIndex;

            short   numCommands = pCommands[0];

            for (commandIndex = 1; commandIndex <= numCommands; ++commandIndex)

                if (pCommands[commandIndex] == commandID)

                    {

                    *menuID = whichMenu;

                    *itemID = commandIndex;

                    returnValue = (commandIndex == numCommands);

                    }

            }   

        }

    UseResFile(oldResFile);

    return returnValue;

} // CommandToIDs

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

#pragma segment Main

Boolean IsCommandEnabled(short commandID)

/*

    returns true if a given command is currently enabled

*/

{

    short       whichMenu, whichItem;

    MenuHandle  menu;

    CommandToIDs(commandID, &whichMenu, &whichItem);

    menu = GetMenuHandle(whichMenu);

    if ((**menu).enableFlags & (1 << whichItem))

        return(true);

    return(false);

} // IsCommandEnabled

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

#pragma segment Main

void EnableCommand(short commandID)

/*

    Given a command ID, enables the first menu item with that command ID.

    If the command table for a given menu is less than the number of items in the menu,

    and the command being enabled is the last item in the command table, then all

    items from there on down are also enabled.  This is useful for menus that get

    appended to, such as the desk accessory list, font list, or speaking voices list.

*/

{

    short   whichMenu;

    short   whichItem;

    if (CommandToIDs(commandID, &whichMenu, &whichItem))

        {

        short       i;

        MenuHandle  menu = GetMenuHandle(whichMenu);

        if (menu)

            {

            short       numItems = CountMItems(menu);

            for (i = whichItem; i <= numItems; ++i)

                EnableItem(menu, i);

            }

        }

    else

        {

        MenuHandle  menu = GetMenuHandle(whichMenu);

        if (menu)

            EnableItem(menu, whichItem);

        }

} // EnableCommand

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

#pragma segment Main

void ChangeCommandName(short commandID, short resourceID, short resourceIndex)

{

    short       whichMenu;

    short       whichItem;

    MenuHandle  menu;

    // figure out how this command maps into the menu bar

    CommandToIDs(commandID, &whichMenu, &whichItem);

    menu = GetMenuHandle(whichMenu);

    // then make this item into the requested new string

    {

    Str255      theString;

    GetIndString(theString, resourceID, resourceIndex);

    SetMenuItemText(menu, whichItem, theString);

    }

} // ChangeCommandName

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

#pragma segment Main

void EnableCommandCheck(short commandID, Boolean check)

{

    short   whichMenu;

    short   whichItem;

    if (CommandToIDs(commandID, &whichMenu, &whichItem))

        {

        short       i;

        MenuHandle  menu = GetMenuHandle(whichMenu);

        short       numItems = CountMItems(menu);

        for (i = whichItem; i <= numItems; ++i)

            {

            EnableItem(menu, i);

            CheckItem(menu, i, check);

            }

        }

    else

        {

        MenuHandle  menu = GetMenuHandle(whichMenu);

        EnableItem(menu, whichItem);

        CheckItem(menu, whichItem, check);

        }

} // EnableCommandCheck

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

#pragma segment Main

void EnableCommandCheckStyle(short commandID, Boolean check, short style)

{

    short   whichMenu;

    short   whichItem;

    if (CommandToIDs(commandID, &whichMenu, &whichItem))

        {

        short       i;

        MenuHandle  menu = GetMenuHandle(whichMenu);

        short       numItems = CountMItems(menu);

        for (i = whichItem; i <= numItems; ++i)

            {

            EnableItem(menu, i);

            CheckItem(menu, i, check);

            SetItemStyle(menu, i, style);

            }

        }

    else

        {

        MenuHandle  menu = GetMenuHandle(whichMenu);

        EnableItem(menu, whichItem);

        CheckItem(menu, whichItem, check);

        SetItemStyle(menu, whichItem, style);

        }

} // EnableCommandCheckStyle

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

#pragma segment Main

void AdjustMenus(WindowRef pWindow, Boolean editDialogs, Boolean forceTitlesOn)

{

    Boolean                 wasEnabled[mNumberMenus];   // Old state of menus

    short                   whichMenu;                  // for stepping through menus

    MenuHandle              menu;                       // for reading in menu IDs

    WindowDataPtr           pData = GetWindowInfo(pWindow);

    // Step through all of the menus 

    for (whichMenu = mApple; whichMenu <= mLastMenu; whichMenu++)

        {

        // Save the old state of the menu title 

        menu = GetMenuHandle(whichMenu);

        if (menu)                               // because contents menu may not be around

            {

            if (forceTitlesOn)              

                wasEnabled[mLastMenu - whichMenu] = false;

            else

                wasEnabled[mLastMenu - whichMenu] = (((**menu).enableFlags && 1) == 1);

            // Disable the entire menu 

            (**menu).enableFlags = 0;       

            }

        }

    // select all, unless someone else changes it

    ChangeCommandName(cSelectAll, kMiscStrings, iSelectAllCommand);

    // if we have NO windows, or the current window is one we understand

    if ((pWindow == nil) || (pData))

        {

        // enable the default commands

        EnableCommand(cAbout);

        EnableCommand(cDeskAccessory);

        EnableCommand(cNew);

        EnableCommand(cOpen);

        EnableCommand(cQuit);

        EnableCommand(cShowClipboard);

        }

    else

        {

        // it's printing or a dialog, so enable cut/copy/paste

        if (editDialogs)

            {

            EnableCommand(cCut);

            EnableCommand(cCopy);

            EnableCommand(cPaste);

            EnableCommand(cClear);

            }

        // and desk accs too!       

        EnableCommand(cDeskAccessory);

        }

    if ( (pWindow) && (pData) )

        {

        // all windows can be closed

        if (FrontWindow())

            EnableCommand(cClose);

        // changed documents can be saved, but only if the file is open for write

        if (    (pData->changed) && 

                ((pData->isWritable) || (pData->dataRefNum == -1)) )

            EnableCommand(cSave);

        // objects with a print method can be printed and page setup-ed

        if (pData->pPrintPage)

            {

            EnableCommand(cPrint);

            EnableCommand(cPageSetup);

            EnableCommand(cPrintOneCopy);

            }

        // let object enable anything else that needs to be enabled

        if (pData->pAdjustMenus)

            (*(pData->pAdjustMenus)) (pWindow, pData);

        }

    // Now determine if any of the menus have changed state

    {

    Boolean gotToRedraw = false;

    for (whichMenu = mApple; whichMenu <= mLastMenu; ++whichMenu)

        {

        menu = GetMenuHandle(whichMenu);

        if (menu)       // because contents menu may not be around

            {

            // If any of the menu is enabled 

            if ((**menu).enableFlags != 0)

                {

                // Make sure to turn on the menu title 

                (**menu).enableFlags |= 1;

                }

            /*  If this new state is different than the saved state, then the menu bar

                will need to be redrawn */

            if (wasEnabled[mLastMenu - whichMenu] != ((**menu).enableFlags && 1))

                {

                gotToRedraw = true;

                }

            }

        }

    // And if any titles have changed state, redraw them 

    if (gotToRedraw)

        DrawMenuBar();

    }

} // AdjustMenus

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

// FILE UTILITY ROUTINES

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

#pragma segment Main

static Boolean BringToFrontIfOpen(FSSpecPtr pSpec)

{

    WindowRef       pWindow;

    pWindow = FrontWindow();

    while (pWindow)

        {

        WindowDataPtr pData = GetWindowInfo(pWindow);

        if (

            (pData) &&

            (pData->fileSpec.vRefNum == pSpec->vRefNum) &&

            (pData->fileSpec.parID == pSpec->parID) &&

            EqualString(pData->fileSpec.name, pSpec->name, false, false)

            )

            {

            SelectWindow(pWindow);

            return true;

            }

        pWindow = GetNextWindow(pWindow);

        }

    return false;

} // BringToFrontIfOpen

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

#pragma segment Main

static Boolean BringToFrontIfExists(ResType windowKind)

{

    WindowRef       pWindow;

    pWindow = FrontWindow();

    while (pWindow)

        {

        WindowDataPtr pData = GetWindowInfo(pWindow);

        if ((pData) && (pData->windowKind == windowKind))

            {

            SelectWindow(pWindow);

            return true;

            }

        pWindow = GetNextWindow(pWindow);

        }

    return false;

} // BringToFrontIfExists

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

// MAIN SIMPLETEXT ROUTINES

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

#pragma segment Main

static OSErr MakeNewWindow(ResType windowKind, FSSpecPtr fileSpec, OSType fileType, Boolean *pWasAlreadyOpen)

{

    OSErr               anErr = fnfErr;

    PreflightRecord     thePreflight;

    PreflightWindowProc pPreflight = nil;

    WindowRef           pWindow;

    WindowDataPtr       pData;

    // require a certain amount of RAM free before we allow the new window to be created

    if (FreeMem() < kRAMNeededForNew)

        anErr = memFullErr;

    // <50> if we already have a document open from this file, bring the window to the

    // front and return with no error

    if ( (fileSpec) && (fileType != 'sEXT') && (BringToFrontIfOpen(fileSpec)) )

        {

        if (pWasAlreadyOpen)

            *pWasAlreadyOpen = true;

        anErr = noErr;

        return(anErr);

        }

    if (pWasAlreadyOpen)

        *pWasAlreadyOpen = false;

    if (anErr != fnfErr)

        {

        nrequire(anErr, SanityCheckFailed);

        }

    // initialize our behavior

    thePreflight.continueWithOpen   = true;

    thePreflight.resourceID         = kDefaultWindowID;

    thePreflight.wantHScroll        = false;

    thePreflight.wantVScroll        = false;

    thePreflight.storageSize        = sizeof(WindowDataRecord);

    thePreflight.makeProcPtr        = nil;

    thePreflight.openKind           = fsRdPerm;

    thePreflight.needResFork        = false;

    thePreflight.doZoom             = false;

    thePreflight.fileType           = fileType;

    switch (windowKind)

        {

        case kAboutWindow:

            pPreflight = AboutPreflightWindow;

            break;

        case kPICTWindow:

            pPreflight = PICTPreflightWindow;

            break;

        case kMovieWindow:

            pPreflight = MoviePreflightWindow;

            break;

        case kClipboardWindow:

            pPreflight = ClipboardPreflightWindow;

            break;

        case kTextWindow:

            pPreflight = TextPreflightWindow;

            break;

        case kThreeDWindow:

            pPreflight = ThreeDPreflightWindow;

            break;

        }

    // preflight the window 

    if (pPreflight)

        anErr = (*pPreflight) (&thePreflight);

    nrequire(anErr, PreflightFailed);

    if (thePreflight.continueWithOpen)

        {

        // allocate a place for the window

        pData = (WindowDataPtr)NewPtrClear(thePreflight.storageSize);

        anErr = MemError();

        nrequire(anErr, FailedToAllocateWindow);

        // then actually create the window

        if (gMachineInfo.theEnvirons.hasColorQD)

            pWindow = (WindowRef)GetNewCWindow(thePreflight.resourceID, pData, (WindowPtr)-1);

        else

            pWindow = (WindowRef)GetNewWindow(thePreflight.resourceID, pData, (WindowPtr)-1);

        if (!pWindow) anErr = memFullErr;

        nrequire(anErr, NewWindowFailed);

        SetWRefCon(pWindow, (long) pData);

        // zoom the rectangle to big size on this monitor 

        // based upon which scroll bars they want

        {

        Rect    rect = GetWindowPort(pWindow)->portRect;

        Rect    bigRect;

        if (gMachineInfo.theEnvirons.hasColorQD)

            bigRect = (**GetMainDevice()).gdRect;

        else

            bigRect = qd.screenBits.bounds;

        bigRect.top += GetMBarHeight() * 2;

        bigRect.left += 4;

        bigRect.bottom -= 4;

        bigRect.right -= 65;

        SetPort((GrafPtr) GetWindowPort(pWindow));

        LocalToGlobal(&TopLeft(rect));

        LocalToGlobal(&BotRight(rect));

        if ( (thePreflight.wantHScroll) || (thePreflight.doZoom) )

            {

            rect.left = bigRect.left;

            rect.right = bigRect.right;

            }

        if ( (thePreflight.wantVScroll) || (thePreflight.doZoom) )

            {

            rect.top = bigRect.top;

            rect.bottom = bigRect.bottom;

            }

        MoveWindow(pWindow, rect.left, rect.top, false);

        SizeWindow(pWindow, rect.right - rect.left, rect.bottom - rect.top, false);

        }

        // fill in the default contents of the window

        pData->windowKind       = windowKind;

        pData->originalFileType = fileType;

        pData->pMakeWindow      = (MakeWindowProc)thePreflight.makeProcPtr;

        pData->resRefNum        = -1;

        pData->dataRefNum       = -1;

        pData->contentRect      = GetWindowPort(pWindow)->portRect;

        // make the scroll bars

        {

        Rect    controlRect;

        if (thePreflight.wantHScroll)

            {

            pData->contentRect.bottom -= kScrollBarSize;

            controlRect = GetWindowPort(pWindow)->portRect;

            controlRect.top = controlRect.bottom - 16;

            if (thePreflight.wantVScroll)

                controlRect.right -= kGrowScrollAdjust;

            OffsetRect(&controlRect, -1, 1);

            pData->hScroll = NewControl(pWindow, &controlRect, "\p", true, 0, 0, 0, scrollBarProc, 0);

            }

        if (thePreflight.wantVScroll)

            {

            pData->contentRect.right -= kScrollBarSize;

            controlRect = GetWindowPort(pWindow)->portRect;

            controlRect.left = controlRect.right - 16;

            if (thePreflight.wantVScroll)

                controlRect.bottom -= kGrowScrollAdjust;

            OffsetRect(&controlRect, 1, -1);

            pData->vScroll = NewControl(pWindow, &controlRect, "\p", true, 0, 0, 0, scrollBarProc, 0);

            }

        }

        // got a name?  Open the file       

        if (fileSpec)

            {

            anErr = FSpOpenDF(fileSpec, thePreflight.openKind, &pData->dataRefNum);

            if  ( 

                    ((anErr == afpAccessDenied) || (anErr == opWrErr) || (anErr == permErr) ) && 

                    (thePreflight.openKind != fsRdPerm)

                )

                {

                thePreflight.openKind = fsRdPerm;

                pData->isWritable = false;

                anErr = FSpOpenDF(fileSpec, thePreflight.openKind, &pData->dataRefNum);

                }

            else

                pData->isWritable = true;

            nrequire(anErr, FailedToOpenFile);

            // okay not to find a resource fork, because some don't have them               

            pData->resRefNum = FSpOpenResFile(fileSpec, thePreflight.openKind);

            // save the file spec in case someone is interested

            pData->fileSpec = *fileSpec;

            }

        if (pData->pMakeWindow)

            {

            Rect oldContent = pData->contentRect;

            anErr = (*(pData->pMakeWindow)) (pWindow, pData);

            if (!EqualRect(&oldContent, &pData->contentRect))

                {

                SizeWindow(pWindow, 

                        pData->contentRect.right  + (pData->vScroll != 0) * kScrollBarSize,

                        pData->contentRect.bottom + (pData->hScroll != 0) * kScrollBarSize,

                        false);

                }

            }

        nrequire(anErr, FailedMakeWindow);

        // got a name?  Use it as the window title

        if ( (fileSpec) && (!pData->openAsNew) )

            SetWTitle(pWindow, fileSpec->name);

        else

            {

            if ((gMachineInfo.documentCount == 1) && (pData->windowKind == kTextWindow))

                {

                Str255 tempString;

                GetIndString(tempString, kMiscStrings, iFirstNewDocumentTitle); // get the "untitled" string (no number)

                SetWTitle(pWindow, tempString);

                }

            else

                {

                Str255  tempString;

                Str32   numString;

                GetWTitle(pWindow, tempString);

                NumToString(gMachineInfo.documentCount, numString);

                (void) ZeroStringSub(tempString, numString);

                SetWTitle(pWindow, tempString);

                }

            if (pData->bumpUntitledCount)

                gMachineInfo.documentCount++;   // bump count if appropriate for this kind of document

            }

        // Make sure the scroll bars are reasonable in size, and move if they must

        AdjustScrollBars(pWindow, true, true, nil);

        // finally, if all goes well, we can see the window itself!

        ShowWindow(pWindow);

        }

    return noErr;

// EXCEPTION HANDLING

FailedMakeWindow:

    if (pData->resRefNum != -1)

        CloseResFile(pData->resRefNum);

    if (pData->dataRefNum != -1)

        FSClose(pData->dataRefNum);

FailedToOpenFile:

    CloseWindow(pWindow);

NewWindowFailed:

    DisposePtr((Ptr)pData);

FailedToAllocateWindow:

PreflightFailed:

SanityCheckFailed:

    return anErr;

} // MakeNewWindow

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

#pragma segment Main

#define dontSaveChanges 3

#define kVisualDelay 8

static pascal Boolean SaveChangesFilter(DialogRef theDialog, EventRecord *theEvent, short *itemHit)

{

    if (StdFilterProc(theDialog, theEvent, itemHit))

        return true;

    if (theEvent->what == updateEvt)

        {

        HandleEvent(theEvent);

        }

    if (theEvent->what == keyDown)

        {

        StringPtr keyEquivs = *GetString(kSaveChangesWindowID);

        unsigned char theKey = theEvent->message & charCodeMask;

        if (keyEquivs && (theKey == keyEquivs[1] || theKey == keyEquivs[2]))

            {

            short itemType;

            Rect theRect;

            ControlRef theControl;

            unsigned long finalTicks;

            GetDialogItem(theDialog, dontSaveChanges, &itemType, (Handle *) &theControl, &theRect);

            HiliteControl(theControl, kControlButtonPart);

            Delay(kVisualDelay, &finalTicks);

            HiliteControl(theControl, 0);

            *itemHit = dontSaveChanges;

            return true;

            }

        }

    return false;

}

static OSErr DoCloseWindow(WindowRef pWindow)

{

    OSErr           anErr = noErr;

    WindowDataPtr   pData = GetWindowInfo(pWindow);

    if ( (pData) && (pData->changed) )

        {

        short       hit;

        Str255      wTitle;

        DialogRef   dPtr;

        GetWTitle(pWindow, wTitle);

        SetCursor(&qd.arrow);

        ParamText(wTitle, "\p", "\p", "\p");

        hit = cancel;

        dPtr = GetNewDialog(kSaveChangesWindowID, nil, (WindowRef)-1);

        if (dPtr)

            {

            SetDialogDefaultItem(dPtr, ok);

            SetDialogCancelItem (dPtr, cancel);

            BeginMovableModal();

            do

                {

                MovableModalDialog(SaveChangesFilter, &hit);

                } while ((hit != dontSaveChanges) && (hit != ok) && (hit != cancel));

            DisposeDialog(dPtr);

            EndMovableModal();

            }

        switch (hit)

            {

            case ok:

                anErr = DoCommand(pWindow, cSave, 0);

                if (anErr == eUserCanceled)     // redundant?

                    gAllDone = false;

                break;

            case cancel:

                anErr = eUserCanceled;

                gAllDone = false;

                break;

            case dontSaveChanges:

                // don't save, so just close it

                break;

            }

        }

    if (anErr == noErr)

        {

        if ( (pData) && (pData->pCloseWindow) )

            {

            // let the object close the window if it wishes to

            anErr = (*(pData->pCloseWindow)) (pWindow, pData);

            }

        // otherwise we close it the default way

        if (anErr == noErr)

            {

            if (pData)

                {

                CloseWindow(pWindow);

                if (pData->hPrint)

                    {

                    DisposeHandle((Handle) pData->hPrint);

                    }

                if (pData->resRefNum != -1)

                    CloseResFile(pData->resRefNum);

                if (pData->dataRefNum != -1)

                    FSClose(pData->dataRefNum);

                DisposePtr((Ptr) pData);

                }

            }

        }

    // If we closed the last window, clean up

    if (FrontWindow() == nil)

        {

        AdjustMenus(nil, true, false);

        gMachineInfo.documentCount = 1;     // back to "untitled"

        }

    return anErr;

} // DoCloseWindow

#undef dontSaveChanges

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

#pragma segment Main

static OSErr    DetermineWindowTypeOrOpen(

    FSSpecPtr theSpec, OSType theType,              // optional input params -- file to open

    OSType *returnedTypeList, short * pNumTypes,    // optional input params -- returns list of files

    Boolean *pWasAlreadyOpen)                       // optional input params -- was file already open

{

    OSErr       anErr = noErr;

    OSType      typeList[20];

    OSType      docList[20];

    short       numTypes;