TweetFollow Us on Twitter

MACINTOSH C CARBON

Demonstration Program Files

Goto Contents

// *******************************************************************************************
// Files.h                                                                  CARBON EVENT MODEL
// *******************************************************************************************
//
// This program demonstrates:
//
// o  File operations associated with:
//
//    o  The user invoking the Open., Close, Save, Save As., Revert, and Quit commands of a
//      typical application.
//
//    o  Handling of the required Apple events Open Application, Re-open Application, Open
//      Documents, Print Documents, and Quit Application.
//
// o  File synchronisation.
//
// o  The creation, display, and handling of Open, Save Location, Choose a Folder, Save
//    Changes, Discard Changes, and Review Unsaved dialogs and alerts using the new model
//    introduced with Navigation Services 3.0.
//
// To keep the code not specifically related to files and file-handling to a minimum, an item
// is included in the Demonstration menu which allows the user to simulate "touching" a window
// (that is, modifying the contents of the associated document).  Choosing the first menu item
// in this menu sets the window-touched flag in the window's document structure to true and
// draws the text "WINDOW TOUCHED" in the window in a large font size, this latter so that the
// user can keep track of which windows have been "touched".
//
// This program is also, in part, an extension of the demonstration program Windows2 in that
// it also demonstrates certain file-related Window Manager features introduced with the Mac
// OS 8.5 Window Manager.  These features are:
//
// o  Window proxy icons.
//
// o  Window path pop-up menus.
//
// Those sections of the source code relating to these features are identified with ///// at
// the right of each line.
//
// The program utilises the following resources:
//
// o  A 'plst' resource containing an information property list which provides information
//    to the Mac OS X Finder.
//
// o  An 'MBAR' resource, and 'MENU' and 'xmnu' resources for Apple, File, Edit and 
//    Demonstration menus (preload, non-purgeable).  
//
// o  A 'STR ' resource containing the "missing application name" string, which is copied to
//    all document files created by the program.
//
// o  'STR#' resources (purgeable) containing error strings, the application's name (for
//    certain Navigation Services functions), and a message  string for the Choose a Folder
//    dialog.
//      
// o  An 'open' resource (purgeable) containing the file type list for the Open dialog.
//
// o  A 'kind' resource (purgeable) describing file types, which is used by Navigation 
//    Services to  build the native file types section of the Show pop-up menu in the Open
//    dialog.
//
// o  Two 'pnot' resources (purgeable) which, together with an associated 'PICT' resource 
//    (purgeable) and a 'TEXT' resource created by the program, provide the previews for
//    the PICT and, on Mac OS 8/9, TEXT files.
//
// o  The 'BNDL' resource (non-purgeable), 'FREF' resources (non-purgeable), signature
//    resource (non-purgeable), and icon family resources (purgeable), required to support the
//    built application on Mac OS 8/9.
//
// o  A 'SIZE' resource with the acceptSuspendResumeEvents, canBackground, 
//    doesActivateOnFGSwitch, and isHighLevelEventAware flags set.
//
// *******************************************************************************************

// .................................................................................. includes

#include <Carbon.h>

// ................................................................................... defines

#define rMenubar                  128
#define mAppleApplication         128
#define  Apple_About              'abou'
#define mFile                     129
#define  File_New                 'new '
#define  File_Open                'open'
#define  File_Close               'clos'
#define  File_Save                'save'
#define  File_SaveAs              'sava'
#define  File_Revert              'reve'
#define  File_Quit                'quit'
#define  iQuit                    12
#define mDemonstration            131
#define  Demo_TouchWindow         'touc'
#define  Demo_ChooseAFolderDialog 'choo'
#define rErrorStrings             128  
#define  eInstallHandler          1000
#define  eMaxWindows              1001
#define  eCantFindFinderProcess   1002                                                   /////
#define rMiscStrings              129
#define  sApplicationName         1
#define  sChooseAFolder           2
#define rOpenResource             128
#define kMaxWindows               10
#define kFileCreator              'Kjbb'
#define kFileTypeTEXT             'TEXT'
#define kFileTypePICT             'PICT'
#define kOpen                     0
#define kPrint                    1
#define MIN(a,b)                  ((a) < (b) ? (a) : (b))

// .................................................................................. typedefs

typedef struct
{
  TEHandle     editStrucHdl;
  PicHandle    pictureHdl;
  SInt16       fileRefNum;
  FSSpec       fileFSSpec;
  AliasHandle  aliasHdl;
  Boolean      windowTouched;
  NavDialogRef modalToWindowNavDialogRef;
  NavEventUPP  askSaveDiscardEventFunctionUPP;
  Boolean      isAskSaveChangesDialog;
}  docStructure, *docStructurePointer, **docStructureHandle;

// ....................................................................... function prototypes

void      main                         (void);
void      eventLoop                    (void);
void      doPreliminaries              (void);
void      doInstallAEHandlers          (void);
OSStatus  appEventHandler              (EventHandlerCallRef,EventRef,void *);
OSStatus  windowEventHandler           (EventHandlerCallRef,EventRef,void *);
void      doIdle                       (void);
void      doDrawContent                (WindowRef);
void      doMenuChoice                 (MenuCommand);
void      doAdjustMenus                (void);
void      doErrorAlert                 (SInt16);
void      doCopyPString                (Str255,Str255);
void      doConcatPStrings             (Str255,Str255);
void      doTouchWindow                (void);
OSErr     openAppEventHandler          (AppleEvent *,AppleEvent *,SInt32);
OSErr     reopenAppEventHandler        (AppleEvent *,AppleEvent *,SInt32);
OSErr     openAndPrintDocsEventHandler (AppleEvent *,AppleEvent *,SInt32);
OSErr     quitAppEventHandler          (AppleEvent *,AppleEvent *,SInt32);
OSErr     doHasGotRequiredParams       (AppleEvent *);
SInt16    doReviewChangesAlert         (SInt16);

OSErr     doNewCommand                 (void);
OSErr     doOpenCommand                (void);
OSErr     doCloseCommand               (NavAskSaveChangesAction);
OSErr     doSaveCommand                (void);
OSErr     doSaveAsCommand              (void);
OSErr     doRevertCommand              (void);

OSErr     doNewDocWindow               (Boolean,OSType,WindowRef *);
EventHandlerUPP  doGetHandlerUPP       (void);
OSErr     doCloseDocWindow             (WindowRef);
OSErr     doOpenFile                   (FSSpec,OSType);
OSErr     doReadTextFile               (WindowRef);
OSErr     doReadPictFile               (WindowRef);
OSErr     doCreateAskSaveChangesDialog (WindowRef,docStructureHandle,NavAskSaveChangesAction);
OSErr     doSaveUsingFSSpec            (WindowRef,NavReplyRecord *);
OSErr     doSaveUsingFSRef             (WindowRef,NavReplyRecord *);
OSErr     doWriteFile                  (WindowRef);
OSErr     doWriteTextData              (WindowRef,SInt16);
OSErr     doWritePictData              (WindowRef,SInt16);

void  getFilePutFileEventFunction   (NavEventCallbackMessage,NavCBRecPtr,NavCallBackUserData);
void  askSaveDiscardEventFunction   (NavEventCallbackMessage,NavCBRecPtr,NavCallBackUserData);

OSErr     doCopyResources              (WindowRef);
OSErr     doCopyAResource              (ResType,SInt16,SInt16,SInt16);

void      doSynchroniseFiles           (void);
OSErr     doChooseAFolderDialog        (void);

// *******************************************************************************************
// Files.c
// *******************************************************************************************

// .................................................................................. includes

#include "Files.h"

// .......................................................................... global variables

Boolean     gRunningOnX = false;
SInt16      gAppResFileRefNum;
NavEventUPP gGetFilePutFileEventFunctionUPP ;
Boolean     gQuittingApplication = false;

extern SInt16 gCurrentNumberOfWindows;
extern Rect   gDestRect,gViewRect;

// ************************************************************************************** main

void  main(void)
{
  MenuBarHandle menubarHdl;
  SInt32        response;
  MenuRef       menuRef;
  EventTypeSpec applicationEvents[] = { { kEventClassApplication, kEventAppActivated    },
                                        { kEventClassCommand,     kEventProcessCommand  },
                                        { kEventClassMenu,        kEventMenuEnableItems } };
  EventLoopTimerRef timerRef;

  // ........................................................................ do preliminaries

  doPreliminaries();

  // .................................. save application's resource file file reference number

  gAppResFileRefNum = CurResFile();

  // ............................................................... set up menu bar and menus
  
  menubarHdl = GetNewMBar(rMenubar);
  if(menubarHdl == NULL)
    doErrorAlert(MemError());
  SetMenuBar(menubarHdl);
  DrawMenuBar();

  Gestalt(gestaltMenuMgrAttr,&response);
  if(response & gestaltMenuMgrAquaLayoutMask)
  {
    menuRef = GetMenuRef(mFile);
    if(menuRef != NULL)
    {
      DeleteMenuItem(menuRef,iQuit);
      DeleteMenuItem(menuRef,iQuit - 1);
    }

    gRunningOnX = true;
  }
  else
  {
    menuRef = GetMenuRef(mFile);
    if(menuRef != NULL)
      SetMenuItemCommandID(menuRef,iQuit,kHICommandQuit);
  }

  // ................................................... install required Apple event handlers

  doInstallAEHandlers();

  // ....................................................... install application event handler
  
  InstallApplicationEventHandler(NewEventHandlerUPP((EventHandlerProcPtr) appEventHandler),
                                 GetEventTypeCount(applicationEvents),applicationEvents,
                                 0,NULL);

  // .............................................. install a timer (for file synchronisation)

  InstallEventLoopTimer(GetCurrentEventLoop(),0,TicksToEventTime(15),
                        NewEventLoopTimerUPP((EventLoopTimerProcPtr) doIdle),NULL,
                        &timerRef);

  // ..... get universal procedure pointer to main Navigation Services services event function

  gGetFilePutFileEventFunctionUPP  = 
                                NewNavEventUPP((NavEventProcPtr) getFilePutFileEventFunction);

  // .............................................................. run application event loop

  RunApplicationEventLoop();
}

// *************************************************************************** doPreliminaries

void  doPreliminaries(void)
{
  MoreMasterPointers(448);
  InitCursor();
}

// *********************************************************************** doInstallAEHandlers

void  doInstallAEHandlers(void)
{
  OSErr osError;

  osError = AEInstallEventHandler(kCoreEventClass,kAEOpenApplication,
                  NewAEEventHandlerUPP((AEEventHandlerProcPtr) openAppEventHandler),
                  0L,false);
  if(osError != noErr)  doErrorAlert(eInstallHandler);

  osError = AEInstallEventHandler(kCoreEventClass,kAEReopenApplication,
                  NewAEEventHandlerUPP((AEEventHandlerProcPtr) reopenAppEventHandler),
                  0L,false);
  if(osError != noErr)  doErrorAlert(eInstallHandler);

  osError = AEInstallEventHandler(kCoreEventClass,kAEOpenDocuments,
                  NewAEEventHandlerUPP((AEEventHandlerProcPtr) openAndPrintDocsEventHandler),
                  kOpen,false);
  if(osError != noErr)  doErrorAlert(eInstallHandler);

  osError = AEInstallEventHandler(kCoreEventClass,kAEPrintDocuments,
                  NewAEEventHandlerUPP((AEEventHandlerProcPtr) openAndPrintDocsEventHandler),
                  kPrint,false);
  if(osError != noErr)  doErrorAlert(eInstallHandler);

  osError = AEInstallEventHandler(kCoreEventClass,kAEQuitApplication,
                  NewAEEventHandlerUPP((AEEventHandlerProcPtr) quitAppEventHandler),
                  0L,false);
  if(osError != noErr)  doErrorAlert(eInstallHandler);
}

// *************************************************************************** appEventHandler

OSStatus  appEventHandler(EventHandlerCallRef eventHandlerCallRef,EventRef eventRef,
                          void * userData)
{
  OSStatus      result = eventNotHandledErr;
  UInt32        eventClass;
  UInt32        eventKind;
  HICommand     hiCommand;
  MenuID        menuID;
  MenuItemIndex menuItem;

  eventClass = GetEventClass(eventRef);
  eventKind  = GetEventKind(eventRef);

  switch(eventClass)
  {
    case kEventClassApplication:
      if(eventKind == kEventAppActivated)
        SetThemeCursor(kThemeArrowCursor);
      break;

    case kEventClassCommand:
      if(eventKind == kEventProcessCommand)
      {
        GetEventParameter(eventRef,kEventParamDirectObject,typeHICommand,NULL,
                          sizeof(HICommand),NULL,&hiCommand);
        menuID = GetMenuID(hiCommand.menu.menuRef);
        menuItem = hiCommand.menu.menuItemIndex;
        if((hiCommand.commandID != kHICommandQuit) && 
           (menuID >= mAppleApplication && menuID <= mDemonstration))
        {
          doMenuChoice(hiCommand.commandID);
          result = noErr;
        }
      }
      break;

    case kEventClassMenu:
      if(eventKind == kEventMenuEnableItems)
      {
        doAdjustMenus();
        result = noErr;
      }
      break;
  }

  return result;
}

// ************************************************************************ windowEventHandler

OSStatus  windowEventHandler(EventHandlerCallRef eventHandlerCallRef,EventRef eventRef,
                             void* userData)
{
  OSStatus  result = eventNotHandledErr;
  UInt32    eventClass;
  UInt32    eventKind;
  WindowRef windowRef;

  eventClass = GetEventClass(eventRef);
  eventKind  = GetEventKind(eventRef);

  switch(eventClass)
  {
    case kEventClassWindow:
      GetEventParameter(eventRef,kEventParamDirectObject,typeWindowRef,NULL,sizeof(windowRef),
                        NULL,&windowRef);
      switch(eventKind)
      {
        case kEventWindowDrawContent:
          doDrawContent(windowRef);
          result = noErr;
          break;

        case kEventWindowClose:
          if(gQuittingApplication)
            doCloseCommand(kNavSaveChangesQuittingApplication);
          else
            doCloseCommand(kNavSaveChangesClosingDocument);
          result = noErr;
          break;
      }
      break;
  }

  return result;
}

// ************************************************************************************ doIdle

void  doIdle(void)
{
  if(GetWindowKind(FrontWindow()) == kApplicationWindowKind)
    doSynchroniseFiles();
}

// ********************************************************************************** doUpdate

void  doDrawContent(WindowRef windowRef)
{
  docStructureHandle docStrucHdl;
  GrafPtr            oldPort;
  Rect               destRect;

  docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);

  GetPort(&oldPort);
  SetPortWindowPort(windowRef);

  if((*docStrucHdl)->pictureHdl)
  {
    destRect = (*(*docStrucHdl)->pictureHdl)->picFrame;
    OffsetRect(&destRect,170,54);
    HLock((Handle) (*docStrucHdl)->pictureHdl);
    DrawPicture((*docStrucHdl)->pictureHdl,&destRect);
    HUnlock((Handle) (*docStrucHdl)->pictureHdl);
  }
  else if((*docStrucHdl)->editStrucHdl)
  {
    HLock((Handle) (*docStrucHdl)->editStrucHdl);
    TEUpdate(&gDestRect,(*docStrucHdl)->editStrucHdl);
    HUnlock((Handle) (*docStrucHdl)->editStrucHdl);
  }

  if((*docStrucHdl)->windowTouched)
  {
    TextSize(48);
    MoveTo(30,170);
    DrawString("\pWINDOW TOUCHED");
    TextSize(12);
  }

  SetPort(oldPort);
}

// ****************************************************************************** doMenuChoice

void  doMenuChoice(MenuCommand commandID)
{
  OSErr osError = noErr;

  switch(commandID)
  {
    // ................................................................ Apple/Application menu

    case Apple_About:
      SysBeep(10);
      break;

    // ............................................................................. File menu

    case File_New:
      if(osError = doNewCommand())
        doErrorAlert(osError);
      break;

    case File_Open:
      if(osError = doOpenCommand() && osError == opWrErr)
        doErrorAlert(osError);
      break;

    case File_Close:
      if(osError = doCloseCommand(kNavSaveChangesClosingDocument))
        doErrorAlert(osError);
      break;

    case File_Save:
      if(osError = doSaveCommand())
        doErrorAlert(osError);
      break;

    case File_SaveAs:
      if(osError = doSaveAsCommand())
        doErrorAlert(osError);
      break;

    case File_Revert:
      if(osError = doRevertCommand())
        doErrorAlert(osError);
      break;

    // .................................................................... Demonstration menu

    case Demo_TouchWindow:
      doTouchWindow();
      break;
      
    case Demo_ChooseAFolderDialog:
      if(osError = doChooseAFolderDialog())
        doErrorAlert(osError);
      break;
  }
}

// ***************************************************************************** doAdjustMenus

void  doAdjustMenus(void)
{
  OSErr              osError;
  MenuRef            menuRef;
  WindowRef          windowRef;
  docStructureHandle docStrucHdl;

  if(gCurrentNumberOfWindows > 0)
  {
    if(gRunningOnX)
    {
      if((osError = GetSheetWindowParent(FrontWindow(),&windowRef)) == noErr)
      {
        menuRef = GetMenuRef(mFile);
        DisableMenuCommand(menuRef,File_Close);
        DisableMenuCommand(menuRef,File_Save);
        DisableMenuCommand(menuRef,File_SaveAs);
        DisableMenuCommand(menuRef,File_Revert);
        menuRef = GetMenuRef(mDemonstration);
        DisableMenuCommand(menuRef,Demo_TouchWindow);
        return;
      }
      else
        windowRef = FrontWindow();
    }
    else
      windowRef = FrontWindow();

    if(GetWindowKind(windowRef) == kApplicationWindowKind)
    {
      docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);

      menuRef = GetMenuRef(mFile);
      EnableMenuCommand(menuRef,File_Close);
      if((*docStrucHdl)->windowTouched)
      {
        EnableMenuCommand(menuRef,File_Save);
        EnableMenuCommand(menuRef,File_Revert);
      }
      else
      {
        DisableMenuCommand(menuRef,File_Save);
        DisableMenuCommand(menuRef,File_Revert);
      }

      if(((*docStrucHdl)->pictureHdl != NULL) || 
         ((*(*docStrucHdl)->editStrucHdl)->teLength > 0))
        EnableMenuCommand(menuRef,File_SaveAs);
      else
        DisableMenuCommand(menuRef,File_SaveAs);

      menuRef = GetMenuRef(mDemonstration);

      if(((*docStrucHdl)->pictureHdl != NULL) || 
         ((*(*docStrucHdl)->editStrucHdl)->teLength > 0))
      {
        if((*docStrucHdl)->windowTouched == false)
          EnableMenuCommand(menuRef,Demo_TouchWindow);
        else
          DisableMenuCommand(menuRef,Demo_TouchWindow);
      }
      else
        DisableMenuCommand(menuRef,Demo_TouchWindow);
    }
  }
  else
  {
    menuRef = GetMenuRef(mFile);
    DisableMenuCommand(menuRef,File_Close);
    DisableMenuCommand(menuRef,File_Save);
    DisableMenuCommand(menuRef,File_SaveAs);
    DisableMenuCommand(menuRef,File_Revert);
    menuRef = GetMenuRef(mDemonstration);
    DisableMenuCommand(menuRef,Demo_TouchWindow);
  }

  DrawMenuBar();
}

// ****************************************************************************** doErrorAlert

void  doErrorAlert(SInt16 errorCode)
{
  Str255 errorString, theString;
  SInt16 itemHit;

  if(errorCode == eInstallHandler)
    GetIndString(errorString,rErrorStrings,1);
  else if(errorCode == eMaxWindows)
    GetIndString(errorString,rErrorStrings,2);
  else if(errorCode == eCantFindFinderProcess)
    GetIndString(errorString,rErrorStrings,3);
  else if(errorCode == opWrErr)
    GetIndString(errorString,rErrorStrings,4);
  else
  {
    GetIndString(errorString,rErrorStrings,5);
    NumToString((SInt32) errorCode,theString);
    doConcatPStrings(errorString,theString);
  }

  if(errorCode != memFullErr)
  {
    StandardAlert(kAlertCautionAlert,errorString,NULL,NULL,&itemHit);
  }
  else
  {
    StandardAlert(kAlertStopAlert,errorString,NULL,NULL,&itemHit);
    ExitToShell();
  }
}

// ***************************************************************************** doCopyPString

void  doCopyPString(Str255 sourceString,Str255 destinationString)
{
  SInt16 stringLength;

  stringLength = sourceString[0];
  BlockMove(sourceString + 1,destinationString + 1,stringLength);
  destinationString[0] = stringLength;
}

// ************************************************************************** doConcatPStrings

void  doConcatPStrings(Str255 targetString,Str255 appendString)
{
  SInt16 appendLength;

  appendLength = MIN(appendString[0],255 - targetString[0]);

  if(appendLength > 0)
  {
    BlockMoveData(appendString+1,targetString+targetString[0]+1,(SInt32) appendLength);
    targetString[0] += appendLength;
  }
}

// ***************************************************************************** doTouchWindow

void  doTouchWindow(void)
{
  WindowRef          windowRef;
  docStructureHandle docStrucHdl;

  windowRef = FrontWindow();
  docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);

  SetPortWindowPort(windowRef);

  TextSize(48);
  MoveTo(30,170);
  DrawString("\pWINDOW TOUCHED");
  TextSize(12);

  (*docStrucHdl)->windowTouched = true;

  SetWindowModified(windowRef,true);                                                     /////
}

// *********************************************************************** openAppEventHandler

OSErr  openAppEventHandler(AppleEvent *appEvent,AppleEvent *reply,SInt32 handlerRefCon)
{
  OSErr osError;

  osError = doHasGotRequiredParams(appEvent);
  if(osError == noErr)
    osError = doNewCommand();

  return osError;
}

// ********************************************************************* reopenAppEventHandler

OSErr  reopenAppEventHandler(AppleEvent *appEvent,AppleEvent *reply,
                               SInt32 handlerRefCon)
{
  OSErr osError;

  osError = doHasGotRequiredParams(appEvent);
  if(osError == noErr)
    if(!FrontWindow())
      osError = doNewCommand();

  return osError;
}

// ************************************************************** openAndPrintDocsEventHandler

OSErr  openAndPrintDocsEventHandler(AppleEvent *appEvent,AppleEvent *reply,
                                    SInt32 handlerRefcon)
{
  FSSpec     fileSpec;
  AEDescList docList;
  OSErr      osError, ignoreErr;
  SInt32     index, numberOfItems;
  Size       actualSize;
  AEKeyword  keyWord;
  DescType   returnedType;
  FInfo      fileInfo;

  osError = AEGetParamDesc(appEvent,keyDirectObject,typeAEList,&docList);

  if(osError == noErr)
  {
    osError = doHasGotRequiredParams(appEvent);
    if(osError == noErr)
    {
      osError = AECountItems(&docList,&numberOfItems);
      if(osError == noErr)
      {
        for(index=1;index<=numberOfItems;index++)
        {
          osError = AEGetNthPtr(&docList,index,typeFSS,&keyWord,&returnedType,
                                &fileSpec,sizeof(fileSpec),&actualSize);
          if(osError == noErr)
          {
            osError = FSpGetFInfo(&fileSpec,&fileInfo);
            if(osError == noErr)
            {
              if(osError = doOpenFile(fileSpec,fileInfo.fdType))
                doErrorAlert(osError);

              if(osError == noErr && handlerRefcon == kPrint)
              {
                // Call printing function here
              }
            }
          }
          else
            doErrorAlert(osError);
        }
      }
    }
    else
      doErrorAlert(osError);

    ignoreErr = AEDisposeDesc(&docList);
  }
  else
    doErrorAlert(osError);

  return osError;
}

// *********************************************************************** quitAppEventHandler

OSErr  quitAppEventHandler(AppleEvent *appEvent,AppleEvent *reply,SInt32 handlerRefcon)
{
  OSErr              osError;
  WindowRef          windowRef, previousWindowRef;
  docStructureHandle docStrucHdl;
  SInt16             touchedWindowsCount = 0;
  EventRef           eventRef;
  EventTargetRef     eventTargetRef;
  SInt16             itemHit;

  osError = doHasGotRequiredParams(appEvent);
  if(osError == noErr)
  {
    if(FrontWindow())
    {
      // ...... if any window has a sheet, bring to front, play system alert sound, and return

      windowRef = GetFrontWindowOfClass(kSheetWindowClass,true);
      if(windowRef)
      {
        SelectWindow(windowRef);
        SysBeep(10);
        return noErr;
      }

      // ............................................................... count touched windows

      windowRef = FrontWindow();
      do
      {
        docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);
        if((*docStrucHdl)->windowTouched == true)
          touchedWindowsCount++;
        previousWindowRef = windowRef;
      } while(windowRef = GetNextWindowOfClass(previousWindowRef,kDocumentWindowClass,true));

      // ............................................ if no touched windows, simply close down

      if(touchedWindowsCount == 0)
        QuitApplicationEventLoop();

      // .............................. if touched windows are present, and if running on OS X

      if(gRunningOnX)
      {

        // .. if one touched window, cause Save Changes alert on that window, close all others

        if(touchedWindowsCount == 1)
        {
          gQuittingApplication = true;
          CreateEvent(NULL,kEventClassWindow,kEventWindowClose,0,kEventAttributeNone,
                      &eventRef);
          eventTargetRef = GetWindowEventTarget(FrontWindow());
          SendEventToEventTarget(eventRef,eventTargetRef);
        }

      // .. if more than one touched window, create Review Changes alert, handle button clicks

      else if(touchedWindowsCount > 1)
      {
        itemHit = doReviewChangesAlert(touchedWindowsCount);

          if(itemHit == kAlertStdAlertOKButton)
          {
            gQuittingApplication = true;
            CreateEvent(NULL,kEventClassWindow,kEventWindowClose,0,kEventAttributeNone,
                        &eventRef);
            eventTargetRef = GetWindowEventTarget(FrontWindow());
            SendEventToEventTarget(eventRef,eventTargetRef);
          }
          else if(itemHit == kAlertStdAlertCancelButton)
            gQuittingApplication = false;
          else if(itemHit == kAlertStdAlertOtherButton)
            QuitApplicationEventLoop();
        }
      }

      // ............................ if touched windows are present, and if running on OS 8/9

      else
      {
        gQuittingApplication = true;
        CreateEvent(NULL,kEventClassWindow,kEventWindowClose,0,kEventAttributeNone,
                    &eventRef);
        eventTargetRef = GetWindowEventTarget(FrontWindow());
        SendEventToEventTarget(eventRef,eventTargetRef);
      }
    }
    else
      QuitApplicationEventLoop();
  }

  return osError;
}

// ******************************************************************** doHasGotRequiredParams

OSErr  doHasGotRequiredParams(AppleEvent *appEvent)
{
  DescType returnedType;
  Size     actualSize;
  OSErr    osError;

  osError = AEGetAttributePtr(appEvent,keyMissedKeywordAttr,typeWildCard,&returnedType,
                            NULL,0,&actualSize);
  if(osError == errAEDescNotFound)
    osError = noErr;
  else if(osError == noErr)
    osError = errAEParamMissed;

  return osError;
}

// ********************************************************************** doReviewChangesAlert

SInt16  doReviewChangesAlert(SInt16 touchedWindowsCount)
{
  AlertStdCFStringAlertParamRec paramRec;
  Str255      messageText1 = "\pYou have ";
  Str255      messageText2 = "\p Files documents with unsaved changes. ";
  Str255      messageText3 = "\pDo you want to review these changes before quitting?";
  Str255      countString;
  CFStringRef messageText;
  CFStringRef informativeText = 
              CFSTR("If you don't review your documents, all your changes will be lost.");
  DialogRef       dialogRef;
  DialogItemIndex itemHit;

  NumToString(touchedWindowsCount,countString);
  doConcatPStrings(messageText1,countString);  
  doConcatPStrings(messageText1,messageText2);  
  doConcatPStrings(messageText1,messageText3);  
  messageText = CFStringCreateWithPascalString(NULL,messageText1,CFStringGetSystemEncoding());

  GetStandardAlertDefaultParams(¶mRec,kStdCFStringAlertVersionOne);
  paramRec.movable      = true;
  paramRec.defaultText  = CFSTR("Review Changes.");
  paramRec.cancelText    = CFSTR("Cancel");
  paramRec.otherText    = CFSTR("Discard Changes");

  CreateStandardAlert(kAlertStopAlert,messageText,informativeText,¶mRec,&dialogRef);
  RunStandardAlert(dialogRef,NULL,&itemHit);

  if(messageText != NULL)
    CFRelease(messageText);

  return itemHit;
}

// *******************************************************************************************
// NewOpenCloseSave.c  
// *******************************************************************************************

// .................................................................................. includes

#include "Files.h"

// .......................................................................... global variables

NavDialogRef gModalToApplicationNavDialogRef;
SInt16       gCurrentNumberOfWindows = 0;
Rect         gDestRect, gViewRect;
Boolean      gCloseDocWindow = false;

extern NavEventUPP gGetFilePutFileEventFunctionUPP;
extern SInt16      gAppResFileRefNum;
extern Boolean     gQuittingApplication;
extern Boolean     gRunningOnX;

// ****************************************************************************** doNewCommand

OSErr  doNewCommand(void)
{
  WindowRef windowRef;
  OSErr     osError;
  OSType    documentType = kFileTypeTEXT;

  osError = doNewDocWindow(true,documentType,&windowRef);

  if(osError == noErr)
    SetWindowProxyCreatorAndType(windowRef,kFileCreator,documentType,kUserDomain);       /////

  return osError;
}

// ***************************************************************************** doOpenCommand

OSErr  doOpenCommand(void)
{
  OSErr                    osError = noErr;
  NavDialogCreationOptions dialogOptions;
  Str255                   applicationName;
  NavTypeListHandle        fileTypeListHdl = NULL;

  // .................................................... create application-modal Open dialog

  osError = NavGetDefaultDialogCreationOptions(&dialogOptions);
  if(osError == noErr)
  {
    GetIndString(applicationName,rMiscStrings,sApplicationName);
    dialogOptions.clientName = CFStringCreateWithPascalString(NULL,applicationName,
                                                              CFStringGetSystemEncoding());
    dialogOptions.modality = kWindowModalityAppModal;
    fileTypeListHdl = (NavTypeListHandle) GetResource('open',rOpenResource);

    osError = NavCreateGetFileDialog(&dialogOptions,fileTypeListHdl,
                                     gGetFilePutFileEventFunctionUPP,NULL,NULL,NULL,
                                     &gModalToApplicationNavDialogRef);
    if(osError == noErr && gModalToApplicationNavDialogRef != NULL)
    {
      osError = NavDialogRun(gModalToApplicationNavDialogRef);
      if(osError != noErr)
      {
        NavDialogDispose(gModalToApplicationNavDialogRef);
        gModalToApplicationNavDialogRef = NULL;
      }
    }
    
    if(dialogOptions.clientName != NULL)
      CFRelease(dialogOptions.clientName);

    if(fileTypeListHdl != NULL)
      ReleaseResource((Handle) fileTypeListHdl);
  }

  return osError;
}

// **************************************************************************** doCloseCommand

OSErr  doCloseCommand(NavAskSaveChangesAction action)
{
  WindowRef          windowRef;
  SInt16             windowKind;
  docStructureHandle docStrucHdl;
  OSErr              osError = noErr;

  windowRef = FrontWindow();
  windowKind = GetWindowKind(windowRef);

  switch(windowKind)
  {
    case kApplicationWindowKind:
      docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);

      // ............................ if window has unsaved changes, create Save Changes alert

      if((*docStrucHdl)->windowTouched == true)
      {
        if(IsWindowCollapsed(windowRef))
          CollapseWindow(windowRef,false);

        osError = doCreateAskSaveChangesDialog(windowRef,docStrucHdl,action);
      }

      // ................................................... otherwise close file and clean up

      else
        osError = doCloseDocWindow(windowRef);
      break;

    case kDialogWindowKind:
      // Hide or close modeless dialog, as required.
      break;
  }

  return osError;
}

// ***************************************************************************** doSaveCommand

OSErr  doSaveCommand(void)
{
  WindowRef          windowRef;
  docStructureHandle docStrucHdl;
  OSErr              osError = noErr;
  Rect               portRect;

  windowRef = FrontWindow();
  docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);

  // ... if the document has a file ref number, write the file, otherwise call doSaveAsCommand

  if((*docStrucHdl)->fileRefNum)
  {
    osError = doWriteFile(windowRef);
    
    SetPortWindowPort(windowRef);
    GetWindowPortBounds(windowRef,&portRect);
    EraseRect(&portRect);
    InvalWindowRect(windowRef,&portRect);
  }
  else
    osError = doSaveAsCommand();

  if(osError == noErr)                                                                   /////
    SetWindowModified(windowRef,false);                                                  /////

  return osError;
}

// *************************************************************************** doSaveAsCommand

OSErr  doSaveAsCommand(void)
{
  OSErr                    osError = noErr;
  NavDialogCreationOptions dialogOptions;
  WindowRef                windowRef;
  Str255                   windowTitle, applicationName;
  docStructureHandle       docStrucHdl;
  OSType                   fileType;

  // ................................................ create window-modal Save Location dialog

  osError = NavGetDefaultDialogCreationOptions(&dialogOptions);
  if(osError == noErr)
  {
    dialogOptions.optionFlags |= kNavNoTypePopup;

    windowRef = FrontWindow();

    GetWTitle(windowRef,windowTitle);
    dialogOptions.saveFileName = CFStringCreateWithPascalString(NULL,windowTitle,
                                                                CFStringGetSystemEncoding());
    GetIndString(applicationName,rMiscStrings,sApplicationName);
    dialogOptions.clientName = CFStringCreateWithPascalString(NULL,applicationName,
                                                              CFStringGetSystemEncoding());
    dialogOptions.parentWindow = windowRef;
    dialogOptions.modality = kWindowModalityWindowModal;
    
    docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);
    if((*docStrucHdl)->editStrucHdl != NULL)
      fileType = kFileTypeTEXT;
    else if((*docStrucHdl)->pictureHdl != NULL)
      fileType = kFileTypePICT;

    HLock((Handle) docStrucHdl);

    osError = NavCreatePutFileDialog(&dialogOptions,fileType,kFileCreator,
                                     gGetFilePutFileEventFunctionUPP ,
                                     windowRef,&(*docStrucHdl)->modalToWindowNavDialogRef);
    HUnlock((Handle) docStrucHdl);

    if(osError == noErr && (*docStrucHdl)->modalToWindowNavDialogRef != NULL)
    {
      osError = NavDialogRun((*docStrucHdl)->modalToWindowNavDialogRef);
      if(osError != noErr)
      {
        NavDialogDispose((*docStrucHdl)->modalToWindowNavDialogRef);
        (*docStrucHdl)->modalToWindowNavDialogRef = NULL;
      }
    }

    if(dialogOptions.saveFileName != NULL)
      CFRelease(dialogOptions.saveFileName);
    if(dialogOptions.clientName != NULL)
      CFRelease(dialogOptions.clientName);
  }

  return osError;
}

// *************************************************************************** doRevertCommand

OSErr  doRevertCommand(void)
{
  OSErr                    osError = noErr;
  NavDialogCreationOptions dialogOptions;
  WindowRef                windowRef;
  Str255                   windowTitle;
  docStructureHandle       docStrucHdl;

  // ............................................... create window-modal Discard Changes alert

  osError = NavGetDefaultDialogCreationOptions(&dialogOptions);
  if(osError == noErr)
  {
    windowRef = FrontWindow();

    GetWTitle(windowRef,windowTitle);
    dialogOptions.saveFileName = CFStringCreateWithPascalString(NULL,windowTitle,
                                                                CFStringGetSystemEncoding());
    dialogOptions.parentWindow = windowRef;
    dialogOptions.modality = kWindowModalityWindowModal;

    docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);
    if((*docStrucHdl)->askSaveDiscardEventFunctionUPP != NULL)
    {
      DisposeNavEventUPP((*docStrucHdl)->askSaveDiscardEventFunctionUPP);
      (*docStrucHdl)->askSaveDiscardEventFunctionUPP = NULL;
    }
    (*docStrucHdl)->askSaveDiscardEventFunctionUPP = 
                            NewNavEventUPP((NavEventProcPtr) askSaveDiscardEventFunction); 

    HLock((Handle) docStrucHdl);

    osError = NavCreateAskDiscardChangesDialog(&dialogOptions,
                                               (*docStrucHdl)->askSaveDiscardEventFunctionUPP,
                                               windowRef,
                                               &(*docStrucHdl)->modalToWindowNavDialogRef);
    HUnlock((Handle) docStrucHdl);

    if(osError == noErr && (*docStrucHdl)->modalToWindowNavDialogRef != NULL)
    {
      osError = NavDialogRun((*docStrucHdl)->modalToWindowNavDialogRef);
      if(osError != noErr)
      {
        NavDialogDispose((*docStrucHdl)->modalToWindowNavDialogRef);
        (*docStrucHdl)->modalToWindowNavDialogRef = NULL;
      }
    }

    if(dialogOptions.saveFileName != NULL)
      CFRelease(dialogOptions.saveFileName);
  }

  return osError;
}

// **************************************************************************** doNewDocWindow

OSErr  doNewDocWindow(Boolean showWindow,OSType documentType,WindowRef * windowRef)
{
  OSStatus           osError;
  WindowAttributes   attributes = kWindowStandardHandlerAttribute |
                                  kWindowStandardDocumentAttributes;
  Rect               portRect, contentRect = { 0,0,300,500 };
  docStructureHandle docStrucHdl;
  EventTypeSpec      windowEvents[] = { { kEventClassWindow, kEventWindowDrawContent  },
                                        { kEventClassWindow, kEventWindowClose        },
                                        { kEventClassWindow, kEventWindowClickDragRgn },
                                        { kEventClassWindow, kEventWindowPathSelect   } };

  if(gCurrentNumberOfWindows == kMaxWindows)
    return eMaxWindows;

  // ..................... create window, change attributes, reposition, install event handler

  osError = CreateNewWindow(kDocumentWindowClass,attributes,&contentRect,windowRef);
  if(osError != noErr)
    return osError;

  SetWTitle(*windowRef,"\puntitled");
  ChangeWindowAttributes(*windowRef,0,kWindowFullZoomAttribute | kWindowResizableAttribute);
  RepositionWindow(*windowRef,NULL,kWindowCascadeOnMainScreen);
  SetPortWindowPort(*windowRef);
  
  InstallWindowEventHandler(*windowRef,doGetHandlerUPP(),GetEventTypeCount(windowEvents),
                            windowEvents,0,NULL);

  // ..................................................... attach document structure to window

  if(!(docStrucHdl = (docStructureHandle) NewHandle(sizeof(docStructure))))
  {
    DisposeWindow(*windowRef);
    return MemError();
  }

  SetWRefCon(*windowRef,(SInt32) docStrucHdl);

  (*docStrucHdl)->editStrucHdl                   = NULL;
  (*docStrucHdl)->pictureHdl                     = NULL;
  (*docStrucHdl)->fileRefNum                     = 0;
  (*docStrucHdl)->aliasHdl                       = NULL;                                 /////
  (*docStrucHdl)->windowTouched                  = false;
  (*docStrucHdl)->modalToWindowNavDialogRef      = NULL;
  (*docStrucHdl)->askSaveDiscardEventFunctionUPP = NULL;
  (*docStrucHdl)->isAskSaveChangesDialog         = false;

  // ............................................. if text document, create TextEdit structure

  if(documentType == kFileTypeTEXT)
  {
    UseThemeFont(kThemeSmallSystemFont,smSystemScript);

    GetWindowPortBounds(*windowRef,&portRect);
    gDestRect = portRect;
    InsetRect(&gDestRect,6,6);
    gViewRect = gDestRect;

    MoveHHi((Handle) docStrucHdl);
    HLock((Handle) docStrucHdl);

    if(!((*docStrucHdl)->editStrucHdl = TENew(&gDestRect,&gViewRect)))
    {
      DisposeWindow(*windowRef);
      DisposeHandle((Handle) docStrucHdl);
      return MemError();
    }

    HUnlock((Handle) docStrucHdl);
  }

  // ............................................ show window and increment open windows count

  if(showWindow)
    ShowWindow(*windowRef);

  gCurrentNumberOfWindows ++;

  return noErr;
}

// *************************************************************************** doGetHandlerUPP

EventHandlerUPP  doGetHandlerUPP(void)
{
  static EventHandlerUPP windowEventHandlerUPP;

  if(windowEventHandlerUPP == NULL)
    windowEventHandlerUPP = NewEventHandlerUPP((EventHandlerProcPtr) windowEventHandler);

  return windowEventHandlerUPP;
}

// ************************************************************************** doCloseDocWindow

OSErr  doCloseDocWindow(WindowRef windowRef)
{
  docStructureHandle docStrucHdl;
  OSErr              osError = noErr;
  EventRef           eventRef;
  EventTargetRef     eventTargetRef;

  docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);

  // ....................... close file, flush volume, dispose of window and associated memory

  if((*docStrucHdl)->fileRefNum != 0)
  {
    if(!(osError = FSClose((*docStrucHdl)->fileRefNum)))  
    {
      osError = FlushVol(NULL,(*docStrucHdl)->fileFSSpec.vRefNum);
      (*docStrucHdl)->fileRefNum = 0;
    }
  }

  if((*docStrucHdl)->editStrucHdl != NULL)
    TEDispose((*docStrucHdl)->editStrucHdl);
  if((*docStrucHdl)->pictureHdl != NULL)
    KillPicture((*docStrucHdl)->pictureHdl);

  DisposeHandle((Handle) docStrucHdl);
  DisposeWindow(windowRef);

  gCurrentNumberOfWindows --;

  // ................................................................. if quitting application

  if(gQuittingApplication)
  {
    if(FrontWindow() == NULL)
      QuitApplicationEventLoop();
    else
    {
      CreateEvent(NULL,kEventClassWindow,kEventWindowClose,0,kEventAttributeNone,
                  &eventRef);
      eventTargetRef = GetWindowEventTarget(FrontWindow());
      SendEventToEventTarget(eventRef,eventTargetRef);
    }
  }

  return osError;
}

// ******************************************************************************** doOpenFile

OSErr  doOpenFile(FSSpec fileSpec,OSType documentType)
{
  WindowRef          windowRef;
  OSErr              osError = noErr;
  SInt16             fileRefNum;
  docStructureHandle docStrucHdl;

  // ....................................................................... create new window

  if(osError = doNewDocWindow(false,documentType,&windowRef))
    return osError;

  SetWTitle(windowRef,fileSpec.name);  

  // ................................................................... open file's data fork

  if(osError = FSpOpenDF(&fileSpec,fsRdWrPerm,&fileRefNum))
  {
    DisposeWindow(windowRef);
    gCurrentNumberOfWindows --;
    return osError;
  }

  // ................... store file reference number and FSSpec in window's document structure

  docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);
  (*docStrucHdl)->fileRefNum = fileRefNum;
  (*docStrucHdl)->fileFSSpec = fileSpec;

  // ........................................................................ read in the file

  if(documentType == kFileTypeTEXT)
  {
    if(osError = doReadTextFile(windowRef))
      return osError;
  }
  else if(documentType == kFileTypePICT)
  {
    if(osError = doReadPictFile(windowRef))
      return osError;
  }

  // ............................................. set up window's proxy icon, and show window

  SetWindowProxyFSSpec(windowRef,&fileSpec);                                             /////
  GetWindowProxyAlias(windowRef,&((*docStrucHdl)->aliasHdl));                            /////
  SetWindowModified(windowRef,false);                                                    /////

  ShowWindow(windowRef);

  return noErr;
}

// ************************************************************** doCreateAskSaveChangesDialog

OSErr  doCreateAskSaveChangesDialog(WindowRef windowRef,docStructureHandle docStrucHdl,
                                    NavAskSaveChangesAction action)
{
  OSErr                    osError = noErr;
  NavDialogCreationOptions dialogOptions;
  Str255                   windowTitle, applicationName;

  // ......................................... create window-modal Save Changes Changes dialog
  
  osError = NavGetDefaultDialogCreationOptions(&dialogOptions);
  if(osError == noErr)
  {
    GetWTitle(windowRef,windowTitle);
    dialogOptions.saveFileName = CFStringCreateWithPascalString(NULL,windowTitle,
                                                                CFStringGetSystemEncoding());

    GetIndString(applicationName,rMiscStrings,sApplicationName);
    dialogOptions.clientName = CFStringCreateWithPascalString(NULL,applicationName,
                                                              CFStringGetSystemEncoding());
    dialogOptions.parentWindow = windowRef;
    dialogOptions.modality = kWindowModalityWindowModal;

    if((*docStrucHdl)->askSaveDiscardEventFunctionUPP != NULL)
    {
      DisposeNavEventUPP((*docStrucHdl)->askSaveDiscardEventFunctionUPP);
      (*docStrucHdl)->askSaveDiscardEventFunctionUPP = NULL;
    }
    (*docStrucHdl)->askSaveDiscardEventFunctionUPP = 
                                NewNavEventUPP((NavEventProcPtr) askSaveDiscardEventFunction);

    HLock((Handle) docStrucHdl);

    osError = NavCreateAskSaveChangesDialog(&dialogOptions,action,
                                            (*docStrucHdl)->askSaveDiscardEventFunctionUPP,
                                            windowRef,
                                            &(*docStrucHdl)->modalToWindowNavDialogRef);
    HUnlock((Handle) docStrucHdl);

    if(osError == noErr && (*docStrucHdl)->modalToWindowNavDialogRef != NULL)
    {
      (*docStrucHdl)->isAskSaveChangesDialog = true;

      osError = NavDialogRun((*docStrucHdl)->modalToWindowNavDialogRef);
      if(osError != noErr)
      {
        NavDialogDispose((*docStrucHdl)->modalToWindowNavDialogRef);
        (*docStrucHdl)->modalToWindowNavDialogRef = NULL;
        (*docStrucHdl)->isAskSaveChangesDialog = false;
      }

      if(!gRunningOnX)
      {
        if(gCloseDocWindow)
        {
          osError = doCloseDocWindow(windowRef);
          if(osError != noErr)
            doErrorAlert(osError);
          gCloseDocWindow = false;    
        }
      }
    }

    if(dialogOptions.saveFileName != NULL)
      CFRelease(dialogOptions.saveFileName);
    if(dialogOptions.clientName != NULL)
      CFRelease(dialogOptions.clientName);
  }

  return osError;
}

// ************************************************************************* doSaveUsingFSSpec

OSErr  doSaveUsingFSSpec(WindowRef windowRef,NavReplyRecord *navReplyStruc)
{
  OSErr              osError = noErr;
  AEKeyword          theKeyword;
  DescType           actualType;
  FSSpec             fileSpec;
  Size               actualSize;
  docStructureHandle docStrucHdl;
  OSType             fileType;
  CFStringRef        fileName;
  SInt16             fileRefNum;
  Rect               portRect;

  if((*navReplyStruc).validRecord)
  {
    // ............................................................................ get FSSpec

    if((osError = AEGetNthPtr(&(*navReplyStruc).selection,1,typeFSS,&theKeyword,
                                &actualType,&fileSpec,sizeof(fileSpec),&actualSize)) == noErr)
    {
      docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);

      // ............. get file name, convert to Pascal string, assign to name field of FSSpec

      fileName = NavDialogGetSaveFileName((*docStrucHdl)->modalToWindowNavDialogRef);
      if(fileName != NULL)
        osError = CFStringGetPascalString(fileName,&fileSpec.name[0],sizeof(FSSpec),
                                          CFStringGetSystemEncoding());

      // ........................................... if not replacing, first create a new file

      if(!((*navReplyStruc).replacing))
      {
        if((*docStrucHdl)->editStrucHdl != NULL)
          fileType = kFileTypeTEXT;
        else if((*docStrucHdl)->pictureHdl != NULL)
          fileType = kFileTypePICT;

        osError = FSpCreate(&fileSpec,kFileCreator,fileType,(*navReplyStruc).keyScript);
        if(osError != noErr)
        {
          NavDisposeReply(&(*navReplyStruc));
          return osError;
        }
      }

      // .................... assign FSSpec to fileFSSpec field of window's document structure

      (*docStrucHdl)->fileFSSpec = fileSpec;

      // ..................................... if file currently exists for document, close it

      if((*docStrucHdl)->fileRefNum != 0)
      {
        osError = FSClose((*docStrucHdl)->fileRefNum);
        (*docStrucHdl)->fileRefNum = 0;
      }

      // ................................................ open file's data fork and write file
      
      if(osError == noErr)
        osError = FSpOpenDF(&(*docStrucHdl)->fileFSSpec,fsRdWrPerm,&fileRefNum);

      if(osError == noErr)
      {
        (*docStrucHdl)->fileRefNum = fileRefNum;
        SetWTitle(windowRef,fileSpec.name);

        // . . . . . . . . . . . . . . . . . . . . . proxy icon and file synchronisation stuff

        SetPortWindowPort(windowRef);                                                    /////
        SetWindowProxyFSSpec(windowRef,&fileSpec);                                       /////
        GetWindowProxyAlias(windowRef,&((*docStrucHdl)->aliasHdl));                      /////
        SetWindowModified(windowRef,false);                                              /////

        // . . . . . . . . . . . . . . . . . . . . . . . . . . . .  write file using safe save
        
        osError = doWriteFile(windowRef);

        NavCompleteSave(&(*navReplyStruc),kNavTranslateInPlace);
      }
    }
  }

  SetPortWindowPort(windowRef);
  GetWindowPortBounds(windowRef,&portRect);
  EraseRect(&portRect);
  InvalWindowRect(windowRef,&portRect);

  return osError;
}

// ************************************************************************** doSaveUsingFSRef

OSErr  doSaveUsingFSRef(WindowRef windowRef,NavReplyRecord *navReplyStruc)
{
  OSErr              osError = noErr;
  AEDesc             aeDesc;
  Size               dataSize;
  FSRef              fsRefParent, fsRefDelete;  
  UniCharCount       nameLength;
  UniChar            *nameBuffer;
  FSSpec             fileSpec;
  docStructureHandle docStrucHdl;
  FInfo              fileInfo;
  SInt16             fileRefNum;
  Rect               portRect;

  osError = AECoerceDesc(&(*navReplyStruc).selection,typeFSRef,&aeDesc);
  if(osError == noErr)
  {
    // ............................................................................. get FSRef

    dataSize = AEGetDescDataSize(&aeDesc);
    if(dataSize > 0)
      osError = AEGetDescData(&aeDesc,&fsRefParent,sizeof(FSRef));
    if(osError == noErr)
    {
      // ............................. get file name from saveFileName field of NavReplyRecord

      nameLength = (UniCharCount) CFStringGetLength((*navReplyStruc).saveFileName);
      nameBuffer = (UniChar *) NewPtr(nameLength);
      CFStringGetCharacters((*navReplyStruc).saveFileName,CFRangeMake(0,nameLength),
                            &nameBuffer[0]);
      if(nameBuffer != NULL)
      {
        // ...................................... if replacing, delete the file being replaced

        if((*navReplyStruc).replacing)
        {
          osError = FSMakeFSRefUnicode(&fsRefParent,nameLength,nameBuffer,
                                       kTextEncodingUnicodeDefault,&fsRefDelete);
          {
            if(osError == noErr)
              osError = FSDeleteObject(&fsRefDelete);
            if(osError == fBsyErr)
            {
              DisposePtr((Ptr) nameBuffer);
              return osError;
            }
          }
        }

        // .............. create file with Unicode name (but it can be written with an FSSpec)

        if(osError == noErr)
        {
          osError = FSCreateFileUnicode(&fsRefParent,nameLength,nameBuffer,kFSCatInfoNone,
                                        NULL,NULL,&fileSpec);
          if(osError == noErr)
          {
            docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);

            osError = FSpGetFInfo(&fileSpec,&fileInfo);

            if((*docStrucHdl)->editStrucHdl != NULL)
              fileInfo.fdType = kFileTypeTEXT;
            else if((*docStrucHdl)->pictureHdl != NULL)
              fileInfo.fdType = kFileTypePICT;
            fileInfo.fdCreator = kFileCreator;

            if(osError == noErr)
              osError = FSpSetFInfo(&fileSpec,&fileInfo);

            (*docStrucHdl)->fileFSSpec = fileSpec;

            // .......................................... open file's data fork and write file

            if(osError == noErr)
              osError = FSpOpenDF(&fileSpec,fsRdWrPerm,&fileRefNum);

            if(osError == noErr)
            {
              (*docStrucHdl)->fileRefNum = fileRefNum;
              SetWTitle(windowRef,fileSpec.name);

              // . . . . . . . . . . . . . . . . . . proxy icon and file synchronisation stuff

              SetPortWindowPort(windowRef);                                              /////
              SetWindowProxyFSSpec(windowRef,&fileSpec);                                 /////
              GetWindowProxyAlias(windowRef,&((*docStrucHdl)->aliasHdl));                /////
              SetWindowModified(windowRef,false);                                        /////

              // . . . . . . . . . . . . . . . . . . . . . . . . .  write file using safe save

              osError = doWriteFile(windowRef);

              NavCompleteSave(&(*navReplyStruc),kNavTranslateInPlace);
            }
          }
        }
      }
    
      DisposePtr((Ptr) nameBuffer);
    }

    AEDisposeDesc(&aeDesc);
  }
  
  SetPortWindowPort(windowRef);
  GetWindowPortBounds(windowRef,&portRect);
  EraseRect(&portRect);
  InvalWindowRect(windowRef,&portRect);

  return osError;
}

// ******************************************************************************* doWriteFile

OSErr  doWriteFile(WindowRef windowRef)
{
  docStructureHandle docStrucHdl;
  FSSpec             fileSpecActual, fileSpecTemp;
  UInt32             currentTime;
  Str255             tempFileName;
  SInt16             tempFileVolNum, tempFileRefNum;
  SInt32             tempFileDirID;
  OSErr              osError = noErr;

  docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);
  fileSpecActual = (*docStrucHdl)->fileFSSpec;

  GetDateTime(¤tTime);
  NumToString((SInt32) currentTime,tempFileName);
  
  osError = FindFolder(fileSpecActual.vRefNum,kTemporaryFolderType,kCreateFolder,
                        &tempFileVolNum,&tempFileDirID);
  if(osError == noErr)
    osError = FSMakeFSSpec(tempFileVolNum,tempFileDirID,tempFileName,&fileSpecTemp);
  if(osError == noErr || osError == fnfErr)
    osError = FSpCreate(&fileSpecTemp,'trsh','trsh',smSystemScript);
  if(osError == noErr)
    osError = FSpOpenDF(&fileSpecTemp,fsRdWrPerm,&tempFileRefNum);
  if(osError == noErr)
  {
    if((*docStrucHdl)->editStrucHdl)
      osError = doWriteTextData(windowRef,tempFileRefNum);
    else if((*docStrucHdl)->pictureHdl)
      osError = doWritePictData(windowRef,tempFileRefNum);
  }  
  if(osError == noErr)
    osError = FSClose(tempFileRefNum);
  if(osError == noErr)
    osError = FSClose((*docStrucHdl)->fileRefNum);
  if(osError == noErr)
    osError = FSpExchangeFiles(&fileSpecTemp,&fileSpecActual);
  if(osError == noErr)
    osError = FSpDelete(&fileSpecTemp);
  if(osError == noErr)
    osError = FSpOpenDF(&fileSpecActual,fsRdWrPerm,&(*docStrucHdl)->fileRefNum);

  if(osError == noErr)
    osError = doCopyResources(windowRef);

  return osError;
}

// **************************************************************************** doReadTextFile

OSErr  doReadTextFile(WindowRef windowRef)
{
  docStructureHandle docStrucHdl;
  SInt16             fileRefNum;
  TEHandle           textEditHdl;
  SInt32             numberOfBytes;
  Handle             textBuffer;
  OSErr              osError = noErr;

  docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);
  fileRefNum = (*docStrucHdl)->fileRefNum;

  textEditHdl = (*docStrucHdl)->editStrucHdl;
  (*textEditHdl)->txSize = 10;
  (*textEditHdl)->lineHeight = 15;

  SetFPos(fileRefNum,fsFromStart,0);
  GetEOF(fileRefNum,&numberOfBytes);

  if(numberOfBytes > 32767)
    numberOfBytes = 32767;

  if(!(textBuffer = NewHandle((Size) numberOfBytes)))
    return MemError();

  osError = FSRead(fileRefNum,&numberOfBytes,*textBuffer);
  if(osError == noErr || osError == eofErr)
  {
    HLockHi(textBuffer);
    TESetText(*textBuffer,numberOfBytes,(*docStrucHdl)->editStrucHdl);
    HUnlock(textBuffer);
    DisposeHandle(textBuffer);
  }
  else
    return osError;

  return noErr;
}

// **************************************************************************** doReadPictFile

OSErr  doReadPictFile(WindowRef windowRef)
{
  docStructureHandle docStrucHdl;
  SInt16             fileRefNum;
  SInt32             numberOfBytes;
  OSErr              osError = noErr;

  docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);
  fileRefNum = (*docStrucHdl)->fileRefNum;

  GetEOF(fileRefNum,&numberOfBytes);
  SetFPos(fileRefNum,fsFromStart,512);
  numberOfBytes -= 512;

  if(!((*docStrucHdl)->pictureHdl = (PicHandle) NewHandle(numberOfBytes)))
    return MemError();

  osError = FSRead(fileRefNum,&numberOfBytes,*(*docStrucHdl)->pictureHdl);
  if(osError == noErr || osError == eofErr)
    return(noErr);
  else
    return osError;
}

// *************************************************************************** doWriteTextData

OSErr  doWriteTextData(WindowRef windowRef,SInt16 tempFileRefNum)
{
  docStructureHandle docStrucHdl;
  TEHandle           textEditHdl;
  Handle             editText;
  SInt32             numberOfBytes;
  SInt16             volRefNum;
  OSErr              osError = noErr;

  docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);
  textEditHdl = (*docStrucHdl)->editStrucHdl;
  editText = (*textEditHdl)->hText;
  numberOfBytes = (*textEditHdl)->teLength;

  osError = SetFPos(tempFileRefNum,fsFromStart,0);
  if(osError == noErr)
    osError = FSWrite(tempFileRefNum,&numberOfBytes,*editText);
  if(osError == noErr)
    osError = SetEOF(tempFileRefNum,numberOfBytes);
  if(osError == noErr)
    osError = GetVRefNum(tempFileRefNum,&volRefNum);
  if(osError == noErr)
    osError = FlushVol(NULL,volRefNum);

  if(osError == noErr)
    (*docStrucHdl)->windowTouched = false;

  return osError;
}

// *************************************************************************** doWritePictData

OSErr  doWritePictData(WindowRef windowRef,SInt16 tempFileRefNum)
{
  docStructureHandle docStrucHdl;
  PicHandle          pictureHdl;
  SInt32             numberOfBytes, dummyData;
  SInt16             volRefNum;
  OSErr              osError = noErr;

  docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);
  pictureHdl = (*docStrucHdl)->pictureHdl;

  numberOfBytes = 512;
  dummyData = 0;

  osError = SetFPos(tempFileRefNum,fsFromStart,0);

  if(osError == noErr)
    osError = FSWrite(tempFileRefNum,&numberOfBytes,&dummyData);

  numberOfBytes = GetHandleSize((Handle) (*docStrucHdl)->pictureHdl);

  if(osError == noErr)
  {
    HLock((Handle) (*docStrucHdl)->pictureHdl);
    osError = FSWrite(tempFileRefNum,&numberOfBytes,*(*docStrucHdl)->pictureHdl);
    HUnlock((Handle) (*docStrucHdl)->pictureHdl);
  }

  if(osError == noErr)
    osError = SetEOF(tempFileRefNum,512 + numberOfBytes);
  if(osError == noErr)
    osError = GetVRefNum(tempFileRefNum,&volRefNum);
  if(osError == noErr)
    osError = FlushVol(NULL,volRefNum);

  if(osError == noErr)
    (*docStrucHdl)->windowTouched = false;

  return osError;
}

// *************************************************************** getFilePutFileEventFunction

void  getFilePutFileEventFunction(NavEventCallbackMessage callBackSelector,
                                  NavCBRecPtr callBackParms,NavCallBackUserData callBackUD)
{
  OSErr              osError = noErr;
  NavReplyRecord     navReplyStruc;
  NavUserAction      navUserAction;
  SInt32             count, index;
  AEKeyword          theKeyword;
  DescType           actualType;
  FSSpec             fileSpec;
  Size               actualSize;
  FInfo              fileInfo;
  OSType             documentType;
  WindowRef          windowRef;
  AEDesc             aeDesc;
  AEKeyword          keyWord;
  DescType           typeCode;
  Rect               theRect;
  Str255             theString, numberString;
  docStructureHandle docStrucHdl;

  switch(callBackSelector)
  {
    case kNavCBUserAction:
      osError = NavDialogGetReply(callBackParms->context,&navReplyStruc);
      if(osError == noErr && navReplyStruc.validRecord)
      {
        navUserAction = NavDialogGetUserAction(callBackParms->context);

        switch(navUserAction)
        {
          // ............................................. click on Open button in Open dialog

          case kNavUserActionOpen:
            if(gModalToApplicationNavDialogRef != NULL)
            {
              osError = AECountItems(&(navReplyStruc.selection),&count);
              if(osError == noErr)
              {
                for(index=1;index<=count;index++)
                {
                  osError = AEGetNthPtr(&(navReplyStruc.selection),index,typeFSS,
                                        &theKeyword,&actualType,&fileSpec,sizeof(fileSpec),
                                        &actualSize);
                  if((osError = FSpGetFInfo(&fileSpec,&fileInfo)) == noErr)
                  {
                    documentType = fileInfo.fdType;
                    osError = doOpenFile(fileSpec,documentType);
                    if(osError != noErr)
                      doErrorAlert(osError);
                  }
                }
              }
            }
            break;

          // .................................... click on Save button in Save Location dialog

          case kNavUserActionSaveAs:
            windowRef = callBackUD;
            osError = AECoerceDesc(&navReplyStruc.selection,typeFSRef,&aeDesc);
            if(osError == noErr)
            {
              osError = doSaveUsingFSRef(windowRef,&navReplyStruc);
              if(osError != noErr)
                doErrorAlert(osError);
              AEDisposeDesc(&aeDesc);
            }
            else
            {
              osError = doSaveUsingFSSpec(windowRef,&navReplyStruc);
              if(osError != noErr)
                doErrorAlert(osError);
            }
            break;

          // ................................ click on Choose button in Choose a Folder dialog

          case kNavUserActionChoose:
            if((osError = AEGetNthPtr(&(navReplyStruc.selection),1,typeFSS,&keyWord,&typeCode,
                                      &fileSpec,sizeof(FSSpec),&actualSize)) == noErr)
            {
              FSMakeFSSpec(fileSpec.vRefNum,fileSpec.parID,fileSpec.name,&fileSpec);
            }
            windowRef = callBackUD;
            SetPortWindowPort(windowRef);
            TextSize(10);
            SetRect(&theRect,0,271,600,300);
            EraseRect(&theRect);
            doCopyPString(fileSpec.name,theString);
            doConcatPStrings(theString, "\p   Volume Reference Number: ");
            NumToString((SInt32) fileSpec.vRefNum,numberString);
            doConcatPStrings(theString,numberString);
            doConcatPStrings(theString, "\p   Parent Directory ID: ");
            NumToString((SInt32) fileSpec.parID,numberString);
            doConcatPStrings(theString,numberString);
            MoveTo(10,290);
            DrawString(theString);
            break;
        }

        osError = NavDisposeReply(&navReplyStruc);
      }
      break;

    case kNavCBTerminate:
      if(gModalToApplicationNavDialogRef != NULL)
      {
        NavDialogDispose(gModalToApplicationNavDialogRef);
        gModalToApplicationNavDialogRef = NULL;
      }
      else
      {
        windowRef = callBackUD;
        docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);
        if((*docStrucHdl)->modalToWindowNavDialogRef != NULL)
        {
          NavDialogDispose((*docStrucHdl)->modalToWindowNavDialogRef);
          (*docStrucHdl)->modalToWindowNavDialogRef = NULL;
        }
      }
      break;
  }
}

// *************************************************************** askSaveDiscardEventFunction

void askSaveDiscardEventFunction(NavEventCallbackMessage callBackSelector,
                                 NavCBRecPtr callBackParms,NavCallBackUserData callBackUD)
{
  WindowRef          windowRef;
  docStructureHandle docStrucHdl;
  NavUserAction      navUserAction;
  OSErr              osError = noErr;
  Rect               portRect;

  switch(callBackSelector)
  {
    case kNavCBUserAction:
      windowRef = callBackUD;
      docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);

      if((*docStrucHdl)->modalToWindowNavDialogRef != NULL)
      {
        navUserAction = NavDialogGetUserAction(callBackParms->context);
        switch(navUserAction)
        {
          // ...................................... click on Save button in Save Changes alert

          case kNavUserActionSaveChanges:
            osError = doSaveCommand();
            if(osError != noErr)
              doErrorAlert(osError);

          // ................................ click on Don't Save button in Save Changes alert

          case kNavUserActionDontSaveChanges:
            NavDialogDispose((*docStrucHdl)->modalToWindowNavDialogRef);
            if(gRunningOnX)
            {
              osError = doCloseDocWindow(windowRef);
              if(osError != noErr)
                doErrorAlert(osError);
            }
            else
              gCloseDocWindow = true;
            break;

          // ..................................... click on OK button in Discard Changes alert

          case kNavUserActionDiscardChanges:
            GetWindowPortBounds(windowRef,&portRect);
            SetPortWindowPort(windowRef);
            EraseRect(&portRect);

            if((*docStrucHdl)->editStrucHdl != NULL && (*docStrucHdl)->fileRefNum != 0)
            {
              osError = doReadTextFile(windowRef);
              if(osError != noErr)
                doErrorAlert(osError);
            }
            else if((*docStrucHdl)->pictureHdl != NULL)
            {
              KillPicture((*docStrucHdl)->pictureHdl);
              (*docStrucHdl)->pictureHdl = NULL;

              osError = doReadPictFile(windowRef);
              if(osError != noErr)
                doErrorAlert(osError);
            }

            (*docStrucHdl)->windowTouched = false;
            SetWindowModified(windowRef,false);                                          /////
            InvalWindowRect(windowRef,&portRect);

            NavDialogDispose((*docStrucHdl)->modalToWindowNavDialogRef);
            (*docStrucHdl)->modalToWindowNavDialogRef = NULL;
            break;

          // ................. click on Cancel button in Save Changes or Discard Changes alert

          case kNavUserActionCancel:
            if((*docStrucHdl)->isAskSaveChangesDialog == true)
            {
              gQuittingApplication = false;
              (*docStrucHdl)->isAskSaveChangesDialog = false;
            }
            NavDialogDispose((*docStrucHdl)->modalToWindowNavDialogRef);
            (*docStrucHdl)->modalToWindowNavDialogRef = NULL;
            break;
        }
      }
      break;
  }
}

// *************************************************************************** doCopyResources

OSErr  doCopyResources(WindowRef windowRef)
{
  docStructureHandle docStrucHdl;
  OSType             fileType;
  OSErr              osError = noErr;
  SInt16             fileRefNum;
  Handle             editTextHdl, textResourceHdl;

  docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);

  if((*docStrucHdl)->editStrucHdl)
    fileType = kFileTypeTEXT;
  else if((*docStrucHdl)->pictureHdl)
    fileType = kFileTypePICT;

  FSpCreateResFile(&(*docStrucHdl)->fileFSSpec,kFileCreator,fileType,smSystemScript);

  osError = ResError();
  if(osError == noErr)
    fileRefNum = FSpOpenResFile(&(*docStrucHdl)->fileFSSpec,fsRdWrPerm);

  if(fileRefNum > 0)
  {
    osError = doCopyAResource('STR ',-16396,gAppResFileRefNum,fileRefNum);

    if(fileType == kFileTypePICT)
    {
      doCopyAResource('pnot',128,gAppResFileRefNum,fileRefNum);
      doCopyAResource('PICT',128,gAppResFileRefNum,fileRefNum);
    }

    if(!gRunningOnX && fileType == kFileTypeTEXT)
    {
      doCopyAResource('pnot',129,gAppResFileRefNum,fileRefNum);
      
      editTextHdl = (*(*docStrucHdl)->editStrucHdl)->hText;
      textResourceHdl = NewHandleClear(1024);
      BlockMoveData(*editTextHdl,*textResourceHdl,1024);      
      UseResFile(fileRefNum);
      AddResource(textResourceHdl,'TEXT',129,"\p");
      if(ResError() == noErr)
        UpdateResFile(fileRefNum);
      ReleaseResource(textResourceHdl);
    }
  }
  else
    osError = ResError();

  if(osError == noErr)
    CloseResFile(fileRefNum); 

  osError = ResError();
  return osError;
}

// *************************************************************************** doCopyAResource

OSErr  doCopyAResource(ResType resourceType,SInt16 resourceID,SInt16 sourceFileRefNum,
                      SInt16 destFileRefNum)
{
  Handle  sourceResourceHdl;
  Str255  sourceResourceName;
  ResType ignoredType;
  SInt16  ignoredID;

  UseResFile(sourceFileRefNum);

  sourceResourceHdl = GetResource(resourceType,resourceID);

  if(sourceResourceHdl != NULL)
  {
    GetResInfo(sourceResourceHdl,&ignoredID,&ignoredType,sourceResourceName);
    DetachResource(sourceResourceHdl);
    UseResFile(destFileRefNum);
    AddResource(sourceResourceHdl,resourceType,resourceID,sourceResourceName);
    if(ResError() == noErr)
      UpdateResFile(destFileRefNum);
  }

  ReleaseResource(sourceResourceHdl);

  return ResError();
}

// *******************************************************************************************
// SynchroniseFiles.c
// *******************************************************************************************

// .................................................................................. includes

#include "Files.h"

// .......................................................................... global variables

extern SInt16  gCurrentNumberOfWindows;

// ************************************************************************ doSynchroniseFiles

void  doSynchroniseFiles(void)
{
  WindowRef          windowRef;
  SInt16             trashVRefNum;
  SInt32             trashDirID;
  docStructureHandle docStrucHdl;
  Boolean            aliasChanged;
  AliasHandle        aliasHdl;
  FSSpec             newFSSpec;
  OSErr              osError;

  windowRef = FrontNonFloatingWindow();

  while(windowRef != NULL)
  {
    docStrucHdl = (docStructureHandle) GetWRefCon(windowRef);

    if(docStrucHdl != NULL)
    {
      if((*docStrucHdl)->aliasHdl == NULL)
        break;

      aliasChanged = false;
      aliasHdl = (*docStrucHdl)->aliasHdl;
      ResolveAlias(NULL,aliasHdl,&newFSSpec,&aliasChanged);

      if(aliasChanged)
      {
        (*docStrucHdl)->fileFSSpec = newFSSpec;
        SetWTitle(windowRef,newFSSpec.name);
      }

      osError = FindFolder(kUserDomain,kTrashFolderType,kDontCreateFolder,&trashVRefNum,
                           &trashDirID);

      if(osError == noErr)
      {
        do
        {
          if(newFSSpec.parID == fsRtParID)
            break;

          if((newFSSpec.vRefNum == trashVRefNum) && (newFSSpec.parID == trashDirID))
          {
            FSClose((*docStrucHdl)->fileRefNum);
            if((*docStrucHdl)->editStrucHdl)
              TEDispose((*docStrucHdl)->editStrucHdl);
            if((*docStrucHdl)->pictureHdl)
              KillPicture((*docStrucHdl)->pictureHdl);
            DisposeHandle((Handle) docStrucHdl);
            DisposeWindow(windowRef);
            gCurrentNumberOfWindows --;
            break;
          }
        } while(FSMakeFSSpec(newFSSpec.vRefNum,newFSSpec.parID,"\p",&newFSSpec) == noErr);
      }
    }

    windowRef = GetNextWindow(windowRef);
  }
}

// *******************************************************************************************
// ChooseAFolderDialog.c
// *******************************************************************************************

// .................................................................................. includes

#include "Files.h"

// .......................................................................... global variables

extern NavEventUPP  gGetFilePutFileEventFunctionUPP ;
extern NavDialogRef gModalToApplicationNavDialogRef;

// ********************************************************************* doChooseAFolderDialog

OSErr  doChooseAFolderDialog(void)
{
  OSErr                    osError = noErr;
  NavDialogCreationOptions dialogOptions;
  WindowRef                windowRef, parentWindowRef;
  Str255                   message;

  osError = NavGetDefaultDialogCreationOptions(&dialogOptions);
  if(osError == noErr)
  {
    if((osError = GetSheetWindowParent(FrontWindow(),&parentWindowRef)) == noErr)
      windowRef = parentWindowRef;
    else
      windowRef = FrontWindow();

    GetIndString(message,rMiscStrings,sChooseAFolder);
    dialogOptions.message = CFStringCreateWithPascalString(NULL,message,
                                                           CFStringGetSystemEncoding());
    dialogOptions.modality = kWindowModalityAppModal;

    osError = NavCreateChooseFolderDialog(&dialogOptions,gGetFilePutFileEventFunctionUPP ,
                                          NULL,windowRef,&gModalToApplicationNavDialogRef);

    if(osError == noErr && gModalToApplicationNavDialogRef != NULL)
    {
      osError = NavDialogRun(gModalToApplicationNavDialogRef);
      if(osError != noErr)
      {
        NavDialogDispose(gModalToApplicationNavDialogRef);
        gModalToApplicationNavDialogRef = NULL;
      }
    }
  }

  return osError;
}

// *******************************************************************************************

Demonstration Program Files Comments

When the program is run, the user should:

o Exercise the File menu by opening the supplied TEXT and PICT files, saving those files,
  saving those files under new names, closing files, opening the new files, attempting to open
  files that are already open, attempting to save files to new files with existing names, 
  making open windows "touched" by choosing the first item in the Demonstration menu, reverting
  to the saved versions of files associated with "touched" windows, choosing Quit when one 
  "touched" window is open, choosing Quit when two or more "touched" windows are open, and so
  on.

o Choose, via the Show pop-up menu button, the file types required to be displayed in the Open
  dialog.

o Choose the Choose a Folder item from the Demonstration menu to display the Choose a Folder
  dialog, and choose a folder using the Choose button at the bottom of the dialog.  (The name 
  of the chosen folder will be drawn in the bottom-left corner of the front window.)

o With either the PICT Document or the TEXT Document open:

  o With the document's Finder icon visible, drag the window proxy icon to the desktop or to
    another open folder, noting that the Finder icon moves to the latter.  Then choose Touch
    Window from the Demonstration menu to simulate unsaved changes to the document.  Note that
    the proxy icon changes to the disabled state.  Then save the file, proving the correct 
    operation of the file synchronisation function.  Note that, after the save, the window 
    proxy icon changes back to the enabled state.

  o Command-click the window's title to display the window path pop-up menu, choose a folder 
    from the menu, and note that the Finder is brought to the foreground and the chosen folder 
    opens.

The program may be run from within CodeWarrior to demonstrate responses to the File menu
commands and the Choose a Folder dialog.

The built application, together with the supplied 'TEXT' and 'PICT' files, may be used to
demonstrate the additional aspect of integrating the receipt of required Apple events with the
overall file handling mechanism.  To prove the correct handling of the required Apple events,
the user should:

o Open the application by double-clicking the application icon, noting that a new document
  window is opened after the application is launched and the Open Application event is 
  received.

o Double click on a document icon, or select one or more document icons and either drag those
  icons to the application icon or choose Open from the Finder's File menu, noting that the
  application is launched and the selected files are opened when the Open Documents event is
  received.

o Close all windows and double-click the application icon, noting that the application responds
  to the Re-open Application event by opening a new window.

o With the PICT Document and the TEXT Document open and "touched", and several other windows
  open, choose Restart or Shut Down from the Mac OS 8/9 Finder's Special menu or the Mac OS X
  Apple menu (thus invoking a Quit Application event), noting that, for "touched" windows, the
  Save Changes alert is presented asking the user whether the file should be saved before the
  shutdown process proceeds.  (On Mac OS X, a Review Unsaved alert will be presented at first.)

Note, however, that no printing functions are included.  Thus, selecting one or more document
icons and choosing Print from the Finder's File menu (Mac OS 8/9) will result in the file/s
opening but not printing.

Files.h

defines

Constants are established for a 'STR#' resource containing error strings for three specific
error conditions, a 'STR#' resource containing the application's name and the message string
for the Choose a Folder dialog, and the 'open' resource containing the file types list.  

KFileCreator represents the application's signature and the next two constants represent the
file types that are readable and writeable by the application.

typedefs

Each window created by the program will have an associated document structure.  The
docStructure data type will be used for document structures.

The editStrucHdl field will be assigned a handle to a TextEdit structure ('TEXT' files).  The
pictureHdl field will be assigned a handle to a Picture structure ('PICT' files).  The
fileRefNum and fileFSSpec fields will be assigned the file reference number and the file system
specification structure of the file associated with the window.  When a file is opened, the
aliasHdl field will be assigned a handle to a structure of type AliasRecord, which contains the
alias data for the file.  The windowTouched field will be set to true when a window has been
made "touched".

When modal-to-the-window Navigation Services dialogs (Save Location, Save Changes, and Discard
Changes alerts) are created, the dialog reference will be assigned to the
modalToWindowNavDialogRef field.  When Save Changes and Discard Changes alerts are created, a
universal procedure pointer to the associated event (callback) function will be assigned to the
askSaveDiscardChangesDialog field.  When a Save Changes alert is created, the
isAskSaveChangesDialog field will be set to true to enable the associated event (callback)
function to re-set a "quitting application" flag if the user clicks the Cancel button in a Save
Changes alert (but not if the user clicks the Cancel button in a Discard Changes alert).

Files.c

Global Variables

gAppResFileRefNum will be assigned the file reference number of the application's resource
fork.  gGetFilePutFileEventFunctionUPP will be assigned a universal procedure pointer to the
event (callback) function associated with the Open, Save Location, and Choose a Folder dialogs.
gQuittingApplication is set to true in certain circumstances within quitAppEventHandler and to
false if the Cancel button is clicked in a Save Changes or Review Unsaved alert.

main

The file reference number of the application's resource fork (which is opened automatically at
application launch) is assigned to the global variable gAppResFileRefNum.

After the required Apple event handlers are installed, the program's application event handler
and an timer are installed.  The timer is set to fire at an interval of 15 ticks, and will be
used to trigger calls to the function doIdle, which calls the program's file synchronisation
function.

A universal procedure pointer to the event (callback) function associated with the Open, Save
Location, and Choose a Folder dialogs is created and assigned to the global variable
gGetFilePutFileEventFunctionUPP.

doInstallAEHandlers

doInstallAEHandlers installs handlers for the Open Application, Re-Open Application, Open
Document, Print Documents, and Quit Application events.  Since the program installs its own
Quit Application event handler, the default Quit Application event handler will not be
installed when RunApplicationEventLoop is called.

windowEventHandler

windowEventHandler is the program's window event handler (a callback function), which is
installed on all document windows.

Note that, when the event type kEventWindowClose is received, the constant passed in the call
to doCloseCommand depends on whether the global variable gQuittingApplication is set to true or
false.  Amongst other things, this constant affects the text in the Save Changes alert.

Note also that no code is required in a Carbon application to handle window path pop-up menus. 
The standard window handler handles all user interaction with window path pop-up menus,
including bringing the Finder to the front when the user chooses a folder.

doIdle

doIdle is called when the installed timer fires.  If the front window is a document window,
doSynchroniseFiles is called to synchronises the application with the actual current location
(and name) of its currently open document files.

doDrawContent

doDrawContent is called when the kEventWindowDrawContent event type is received.  It performs
such window updating as is necessary for the satisfactory execution of the demonstration
aspects of the program.

doMenuChoice

At the File_Close case, kNavSaveChangesClosingDocument is passed in the call to doCloseCommand. 
This affects the wording in the Save Changes alert.

doAdjustMenus

If the program is running on Mac OS X, GetSheetWindowParent is called as a way of determining
whether the frontmost window is a sheet.  If it is, the File and Demonstration menus are
adjusted accordingly.

doTouchWindow

doTouchWindow is called when the user chooses the Touch Window item in the Demonstration menu. 
Changing the content of the in-memory version of a file is only simulated in this program.  The
text "WINDOW TOUCHED" is drawn in window and the windowTouched field of the document structure
is set to true.

SetWindowModified is called with true passed in the modified parameter.  This causes the proxy
icon to appear in the disabled state, indicating that the window has unsaved changes.
openAppEventHandler, reopenAppEventHandler, and openAndPrintDocsEventHandler
The handlers for the first four required Apple events are essentially identical to those in the
demonstration program AppleEvents.  One major difference is that one handler
(openAndPrintDocsEventHandler) is used for both the Open Documents and Print Documents events,
with a value passed in the handler's handlerRefcon parameter advising the handler which of the
two events has been received.

Most programs should simply open a new untitled window on receipt of an Open Application event. 
Accordingly, openAppEventHandler simply calls the same function (doNewCommand) as is called
when the user chooses New from the File menu.

On receipt of a Re-Open Application event, if no windows are currently open, doNewCommand is
called to open a window.

The demonstration program supports both 'TEXT' and 'PICT' files.  On receipt of an Open
Application event, it is thus necessary to determine the type of each file specified in the
event.  Accordingly, within openAndPrintDocsEventHandler, the call to FSpGetFInfo returns the
Finder information from the volume catalog entry for the file relating to the specified FSSpec
structure.  The fdType field of the FInfo structure "filled-in" by FSpGetFInfo contains the
file type.  This, together with the FSSpec structure, is then passed in the call to doOpenFile. 
(doOpenFile is also called when the user chooses Open from the File menu.)

quitAppEventHandler

Much of the code in quitAppEventHandler has to do with the requirement, on Mac OS X only, to
present a Review Unsaved alert if more than one window with unsaved changes is open when the
event is received.

If no windows are open, QuitApplicationEventLoop is called to close the application down.  If
at least one window is open, the following occurs.

GetFrontWindowOfClass is called to determine whether any window has a sheet.  If so, that
window is brought to the front and activated and the handler returns immediately, keeping the
application alive.

The do-while loop walks the window list counting the number of document windows with unsaved
changes (that is, "touched" windows) and, at the same time, bringing those windows to the
front.  At the next block, if there are no touched document windows, QuitApplicationEventLoop
is called to close the application down.

If the application is running on Mac OS X, the following occurs:

o If there is only one touched window open, the flag gQuittingApplication is set to true and a
  kEventWindowClose event is created and sent to the front window.  As will be see, this
  results in a sequence involving doCloseCommand and doCloseDocWindow whereby all untouched
  windows in front of the touched window are disposed of and a Save Changes alert is presented 
  for the touched window.  In this sequence, if the event handler for the Save Changes alert 
  detects a Cancel button click, gQuittingApplication will be set to false, an action which 
  will cause the process of closing down the remaining windows and the application to be 
  terminated.  If the Save or Don't Save buttons are clicked, all remaining windows will be 
  closed down, and the program will be closed down by a call to QuitApplicationEventLoop,
  within the function doCloseDocWindow.

o If more than one window has been touched, doReviewChangesAlert is called to create, display 
  and handle a Review Changes alert.  If the Review ChangesÉ button is hit, the flag
  gQuittingApplication is set to true and a kEventWindowClose event is created and sent to the
  front window, resulting in the same general process of close-down, and possible termination
  of that close-down process, described above.  If the Cancel button is hit, the flag
  gQuittingApplication is set to false (which defeats the execution of the last block of code
  in doCloseDocWindow) and quitAppEventHandler simply returns.  If the Discard Changes button 
  is hit, QuitApplicationEventLoop is called to terminate the program.

If the application is running on Mac OS 8/9, a Review Unsaved alert is not invoked.  Instead, a
kEventWindowClose event is created and sent to the front window.  This results in the the same
general process of close-down, and possible termination of that close-down process, described
above.  If the Cancel button is not clicked in all Save Changes alerts, all windows will be
closed down, and QuitApplicationEventLoop called, within the function doCloseDocWindow.

NewOpenCloseSave.c

Global Variables

gModalToApplicationNavDialogRef will be assigned the dialog reference for the Open File dialog,
which is made application-modal.  gCurrentNumberOfWindows keeps a count of the number of
windows opened.  gDestRect and gViewRect are used to set the destination and view rectangles
for the TextEdit structures associated with 'TEXT' files.

doNewCommand

doNewCommand is called when the user chooses New from the File menu and when an Open
Application or Re-Open Application event is received.

Since this demonstration does not support the actual entry of text or the drawing of graphics,
the document type passed to doNewDocWindow is immaterial.  The document type 'TEXT' is passed
in this instance simply to keep doNewDocWindow happy.

If doNewDocWindow returns no error, SetWindowProxyCreatorAndType is called to set the proxy
icon for the window.  (A new, untitled window, even though it has no associated file, needs a
proxy icon to maintain visual consistency with other windows which have associated files.)  The
proxy icon will display in the disabled state, indicating, in this particular case, that the
window has no associated file rather than unsaved changes.

The creator code and file type passed in the second and third parameters of
SetWindowProxyCreatorAndType determine the icon to be displayed.)

doOpenCommand

doOpenCommand, which is called when the user chooses Open from the File menu, uses Navigation
Services 3.0 functions to create and display a application-modal Open dialog.

NavGetDefaultDialogCreationOptions initialises the specified NavDialogCreationOptions structure
with the defaults.

GetIndString retrieves the application's name and assigns it to an Str255 variable.  This is
then converted to a CFString and assigned to the clientName field of the
NavDialogCreationOptions structure.  This will cause the application's name to appear in the
dialog's title bar.

The next line assigns a value to the modality field of the NavDialogCreationOptions structure
which will cause the dialog to be application-modal.

An 'open' resource containing the file type list is then read in and the handle assigned a
variable of type NavTypeListHandle.  (The 'open' resource specifies that 'TEXT' and 'PICT' file
types are supported.)

The call to NavCreateGetFileDialog creates the dialog.  Since the default options are being
used, multiple file selection is allowed.  A universal procedure pointer to the event function
getFilePutFileEventFunction, which will respond to button clicks in the dialog, is passed in
the third parameter.  No preview function or filter function is used, and no user data is
passed in.  The last parameter (a global variable) receives the dialog reference.

The call to NavDialogRun displays the dialog.

doCloseCommand

doCloseCommand is called when the user chooses Close from the File menu or clicks in the
window's go-away box.  It is also called successively for each open window when a Quit
Application Apple event is received.

The first two lines get a reference to the front window and establish whether the front window
is a document window or a modeless dialog.

If the front window is a document window, the handle to the window's document structure is
retrieved from the window's window object, allowing a check of whether the window is touched
(that is, has unsaved changes).  If it does, doCreateAskSaveChangesDialog is called to create
and display a Save Changes alert and the function returns, otherwise doCloseDocWindow is
called.  Prior to the call to doCreateAskSaveChangesDialog, if the window is collapsed (Mac OS
8/9) or minimized in the dock (Mac OS X) it is first uncollapsed or brought out of the Dock.

No modeless dialogs are used by this program.  However, if the front window was a modeless
dialog, the appropriate action would be taken at the second case.

doSaveCommand

doSaveCommand is called when the user chooses Save from the File menu or clicks the Save button
in a Save Changes alert.

The first two lines get the WindowRef for the front window and retrieve the handle to that
window's document structure.  If a file currently exists for the document in this window, the
function doWriteFile is called.  The next four lines are incidental to the demonstration; they
simply remove the words "WINDOW TOUCHED" from the window.

SetWindowModified is called with false passed in the modified parameter.  This causes the
window proxy icon to appear in the enabled state, indicating no unsaved changes.

doSaveAsCommand

doSaveAsCommand uses Navigation Services 3.0 functions to create and display a window-modal
Save Location dialog.  It is called when the user chooses Save AsÉ from the File menu.  It is
also called by doSaveCommand if the user chooses Save when the front window contains a document
for which no file currently exists.

NavGetDefaultDialogCreationOptions initialises the specified NavDialogCreationOptions structure
with the defaults.  The first line in the if block unsets the "allow saving of stationery
files" bit (one of the defaults).  On Mac OS 8/9, this means that the dialog will not contain
the Format: pop-up menu.

GetWTitle gets the front window's title into an Str255 variable.  This is then converted to a
CFString and assigned to the saveFileName field of the NavDialogCreationOptions structure. 
This will be the default name for the saved file and will appear in the Name (OS 8/9) and Save
As (OS X) edit text fields in the Save Location dialog.

The next two lines assign the application's name to the clientName field of the
NavDialogCreationOptions structure.  This will then appear in the dialog's title bar.

The next two lines assign the window reference to the parentWindow field of the
NavDialogCreationOptions structure and assign a value to the modality field which will cause
the dialog to be window-modal.

The next block gets the file type from the window's document structure into a local variable.

The call to NavCreatePutFileDialog creates the dialog.  A universal procedure pointer to the
event function getFilePutFileEventFunction, which will respond to button clicks in the dialog,
is passed in the fourth parameter.  The window reference is passed in the fifth (user data)
parameter.  This will be passed to the event function.  The dialog reference is assigned to a
field of the window's document structure.

The call to NavDialogRun displays the dialog.

doRevertCommand

doRevertCommand, which is called when the user chooses Revert from the File menu, uses
Navigation Services 3.0 functions to create and display a window-modal Discard Changes alert. 
The general approach is similar to that used to create and display the Save Location dialog,
the main difference being that a universal procedure pointer to the event function
askSaveDiscardEventFunction is stored in the askSaveDiscardEventFunctionUPP field of the
window's document structure.

doNewDocWindow

doNewDocWindow is called by doNewCommand and doOpenFile.

If the current number of open windows is the maximum allowable by this program, the function
immediately exits, returning an error code which will cause an advisory error alert to be
displayed.

The call to CreateNewWindow creates a new window with the standard document window attributes
and with the standard window event handler installed.  SetWTitle is called to set the window's
title to "untitled".  ChangeWindowAttributes is called to remove the zoom box/button and grow
box from the window.  The call to InstallWindowEventHandler installs the program's window event
handler on the window.  

The call to NewHandle allocates memory for the window's document structure.  If this call is
not successful, the window is disposed of and the function returns with the error code returned
by MemError.  The call to SetWRefCon assigns the handle to the document structure to the window
structure's refCon field.  The next block initialises fields of the document structure.

If the document type is 'TEXT', the if block executes, creating a TextEdit structure and
assigning a handle to that structure to the editStrucHdl field of the document structure. 
(Note that the processes here are not explained in detail because TextEdit and TextEdit
structures are not central to the demonstration.  For the purposes of the demonstration, it is
sufficient to understand that the text data retrieved from, and saved to, disk is stored in a
TextEdit structure.  (TextEdit is addressed in detail at Chapter 21.))

If the Boolean value passed to doNewDocWindow was set to true, the call to ShowWindow makes the
window visible, otherwise the window is left invisible.  The penultimate line increments the
global variable which keeps track of the number of open windows.

doCloseDocWindow

doCloseDocWindow is called from doCloseCommand when the subject window is not touched and from
the Save Changes alert event handler askSaveDiscardEventFunction when the user clicks the Save
or Don't Save buttons in a Save Changes alert.

The FSClose call closes the file, and FlushVol stores to disk all unwritten data currently in
the volume buffer.

If the document is a text document, the TextEdit structure is disposed of.  If it is a picture
document, the Picture structure is disposed of.  Finally, the document structure and window are
disposed of and the global variable which keeps track of the number of open windows is
decremented.

The last block executes only if gQuittingApplication has been set to true in the function
quitAppEventHandler.  If all windows have been closed, QuitApplicationEventLoop is called to
terminate the program; otherwise a kEventWindowClose is created and sent to the front window,
causing doCloseCommand to be called from the window event handler.  This repetitive calling of
doCloseCommand and doCloseDocWindow will continue until no windows remain or until
gQuittingApplication is set to false by a click in the Cancel button in a Save Changes or, on
Mac OS X only, a Review Unsaved alert.

doOpenFile

doOpenFile opens a new document window and calls the functions which read in the file.  It is
called by the event function getFilePutFileEventFunction when an Open button click occurs in an
Open dialog.  The event function passes the file system specification structure and document
type to doOpenFile.

The call to doNewDocWindow opens a new window and creates an associated document structure. 
SetWTitle sets the window's title using information in the file system specification structure. 
FSpOpenDF opens the file's data fork.  If this call is not successful, the window is disposed
of and the function returns.  The next three lines assign the file reference number and file
system specification structure to the relevant fields of the document structure.

The next block calls the appropriate function for reading in the file, depending on whether the
file type is of type 'TEXT' or 'PICT'.  If the file is read in successfully, ShowWindow makes
the window visible.

Just before the call to ShowWindow, SetWindowProxyFSSpec is called to establish a proxy icon
for the window and associate the file with the window.  (The creator code and file type of the
file determine the icon to be displayed.)  GetWindowProxyAlias assigns a copy of the alias data
for the file to the aliasHdl field of the window's document structure.  (This is used by the
file synchronisation function.)  SetWindowModified is called with false passed in the modified
parameter.  This causes the window proxy icon to appear in the enabled state, indicating no
unsaved changes.

doCreateAskSaveChangesDialog

doCreateAskSaveChangesDialog, which is called from doCloseCommand, uses Navigation Services 3.0
functions to create and display a window-modal Save Changes alert.  The general approach is
similar to that used to create and display the Discard Changes alert, but note that in this
case that the isAskSaveChangesDialog field of the window's document structure is set to true.

Note also that, if the program is running on Mac OS 8/9, and if gCloseDocWindow is true, 
doCloseDocWindow is called to close the file, flush the volume, and close down the window.  
(gCloseDocWindow is set to true in the callback function askSaveDiscardEventFunction if the user 
clicks the Don't Save push button button in the Save Changes alert.)

doSaveUsingFSSPec

As will be seen in the event function getFilePutFileEventFunction, when the user clicks on the
Save button in a Save Location dialog, AECoerceDesc is called on the descriptor structure in
the selection field of the NavReplyRecord structure in an attempt to coerce it to type FSRef. 
If the call is successful (meaning that the program is running on Mac OS X), doSaveUsingFSRef
is called to perform the save using the HFS Plus API.  If the call is not successful (meaning
that the program is running on Mac OS 8/9) this function (doSaveUsingFSSpec) is called.

A descriptor structure is returned in the selection field of the NavReplyRecord structure. 
AEGetNthPtr coerces the descriptor structure to typeFSS and stores the result in the local
variable fileSpec.

The name field of fileSpec will be empty at this stage.  Accordingly, the Navigation Services
3.0 function NavDialogGetSaveFileName is called to get a CFStringRef to the filename from the
dialog object, which is converted to a Pascal string and assigned to the name field of
fileSpec.

If the value in the replacing field of the NavReplyRecord structure indicates that the file is
not being replaced, FSpCreate is called to create a new file of the specified type and with the
application's signature as the specified creator.  If this call is not successful, the
NavReplyRecord structure is disposed of and the function returns.

The file system specification structure returned by the FSpCreate call is assigned to the
fileFSSpec field of the window's document structure.  If a file currently exists for the
document, that file is closed by the call to FSClose.  The data fork of the newly created file
is then opened by a call to FSpOpenDF, the fileRefNum field of the document structure is
assigned the file reference number returned by FSpOpenDF, the window's title is set to the new
file's name, and the function doWriteFile is called to write the document to the new file. 
NavCompleteSave is called to complete the save operation.

Just before the call to doWriteFile, SetWindowProxyFSSpec is called to establish a proxy icon
for the window and associate the file with the window.  (The creator code and file type of the
file determine the icon to be displayed.)  GetWindowProxyAlias assigns a copy of the alias data
for the file to the aliasHdl field of the window's document structure.  (This is used by the
file synchronisation function.)  SetWindowModified is called with false passed in the modified
parameter.  This causes the window proxy icon to appear in the enabled state, indicating no
unsaved changes.

doSaveUsingFSRef

doSaveUsingFSRef, which is called from the event function getFilePutFileEventFunction, performs
the save using the HFS Plus API.  The main if block executes only if the call to AECoerceDesc
is successful in coercing the descriptor structure in the selection field of the NavReplyRecord
to type FSRef.

In Carbon, the dataHandle field of descriptor structures is opaque.  Thus AEGetDescData is used
to extract the data in this field, which is assigned to the local variable fsRefParent.  This
is the FSRef for the parent directory.

At the next block, CFStringGetLength is called to get the number of 16-bit Unicode characters
in the saveFileName field of the NavReplyRecord structure.  This facilitates the call to
CFStringGetCharacters, which extracts the contents of the string into a buffer.

If the value in the replacing field of the NavReplyRecord structure indicates that the file is
being replaced, the existing file is first deleted.  FSMakeFSRefUnicode, given a parent
directory and Unicode file name, creates an FSRef for the file.  This is passed in the call to
FSDeleteObject, which deletes the file.

The call to FSCreateFileUnicode creates a new file with the Unicode name.  On return, the last
parameter contains a file system specification structure for the new file.  (Although the file
is created with a Unicode name, it can be written using a file system specification structure.)

The call to FSpGetFInfo gets the Finder information from the volume catalog entry for the file.
The file type extracted from the window's document structure is then assigned to the fdType
field of the returned FInfo structure, following which FSpSetFInfo is called to set the new
Finder information in the file's volume catalog entry.

The file system specification structure is assigned to the fileFSSpec field of the window's
document structure.

The data fork of the newly created file is then opened by a call to FSpOpenDF, the fileRefNum
field of the document structure is assigned the file reference number returned by FSpOpenDF,
the window's title is set to the new file's name, and the function doWriteFile is called to
write the document to the new file.  NavCompleteSave is called to complete the save operation.

Just before the call to doWriteFile, SetWindowProxyFSSpec is called to establish a proxy icon
for the window and associate the file with the window.  (The creator code and file type of the
file determine the icon to be displayed.)  GetWindowProxyAlias assigns a copy of the alias data
for the file to the aliasHdl field of the window's document structure.  (This is used by the
file synchronisation function.)  SetWindowModified is called with false passed in the modified
parameter.  This causes the window proxy icon to appear in the enabled state, indicating no
unsaved changes.

doWriteFile

doWriteFile is called by doSaveCommand, doSaveUsingFSSPec, and doSaveUsingFSRef.  In
conjunction with two supporting functions, it writes the document to disk using the "safe-save"
procedure.

The first two lines retrieve a handle to the document structure and the file system
specification from the document structure.

The next two lines create a temporary file name which is bound to be unique.  FindFolder finds
the temporary folder on the file's volume, or creates a temporary folder if necessary. 
FSMakeFSSpec makes a file system specification structure for the temporary file, using the
volume reference number and parent directory ID returned by the FindFolder call.  FSpCreate
creates the temporary file in that directory on that volume, and FSpOpenDF opens the file's
data fork.

Within the next if block, the appropriate function is called to write the document's data to
the temporary file.

The two calls to FSClose close both the temporary and existing files prior to the call to
FSpExchangeFiles, which swaps the files' data.  The temporary file is then deleted and the data
fork of the existing file is re-opened.

The function doCopyResources is called to copy the missing application name string resource
from the resource fork of the application file to the resource fork of the new document file. 
If the file type is 'PICT', a 'pnot' resource and associated 'PICT' resource is also copied to
the resource fork.

doReadTextFile

doReadTextFile is called by doOpenFile and the event function askSaveDiscardEventFunction to
read in data from an open file of type 'TEXT'.

The first two lines retrieve the file reference number from the document structure.  

The next three lines retrieve the handle to the TextEdit structure from the document structure
and modify the text size and line height fields of the TextEdit structure.

SetFPos sets the file mark to the beginning of the file.  GetEOF gets the number of bytes in
the file.  If the number of bytes exceeds that which can be stored in a TextEdit structure
(32,767), the number of bytes which will be read from the file is restricted to 32,767.

NewHandle allocates a buffer equal to the size of the file (or 32,767 bytes if the preceding if
statement executed).  FSRead reads the data from the file into the buffer.  MoveHHi and HLockHi
move the buffer high in the heap and lock it preparatory to the call to TESetText.  TESetText
copies the text in the buffer into the existing hText handle of the TextEdit edit structure. 
The buffer is then unlocked and disposed of.

doReadPictFile

doReadPictFile is called by doOpenFile and the event function askSaveDiscardEventFunction to
read in data from an open file of type 'PICT'.

The first two lines retrieve the file reference number from the document structure.  GetEOF
gets the number of bytes in the file.  SetFPos sets the file mark 512 bytes (the size of a
'PICT' file's header) past the beginning of the file, and the next line subtracts the header
size from the total size of the file.  NewHandle allocates memory for the Picture structure and
FSRead reads in the file's data.

doWriteTextData

doWriteTextData is called by doWriteFile to write text data to the specified file.

The first two lines retrieve the handle to the TextEdit structure from the document structure. 
The number of bytes of text is then retrieved from the teLength field of the TextEdit
structure.

SetFPos sets the file mark to the beginning of the file.  FSWrite writes the specified number
of bytes to the file.  SetEOF adjusts the file's size.  FlushVol stores to disk all unwritten
data currently in the volume buffer.

The penultimate line sets the windowTouched field of the document structure to indicate that
the document data on disk equates to the document data in memory.
doWritePictData
doWritePictData is called by doWriteFile to write picture data to the specified file.

The first two lines retrieve the handle to the relevant Picture structure from the document
structure.  SetFPos sets the file mark to the start of the file.  FSWrite writes zeros in the
first 512 bytes (the size of a 'PICT' file's header).  GetHandleSize gets the size of the
Picture structure and FSWrite writes the bytes in the Picture structure to the file.  SetEOF
adjusts the file's size and FlushVol stores to disk all unwritten data currently in the volume
buffer.

The penultimate line sets the windowTouched field of the document structure to indicate that
the document data on disk equates to the document data in memory.

getFilePutFileEventFunction

getFilePutFileEventFunction is the event (callback) function pertaining to the Open, Save
Location, and Choose a Folder dialogs.  It responds to button clicks in those dialogs.

When the user has clicked one of the dialog's buttons, the kNavCBUserAction message is received
in the callBackSelector formal parameter.  When this message is received, the first action is
to call NavDialogGetReply to get a NavReplyRecord structure containing information about the
dialog session.  NavDialogGetUserAction is then called to get the user action which dismissed
the dialog.

If the user clicked the Open button in an Open dialog, AECountItems is called to count the
number of descriptor structures in the descriptor list returned in the selection field of the
NavReplyRecord structure, and which is created from FSSpec references to items selected in the
Open dialog.  The for loop repeats for each of the descriptor structures.  AEGetNthPtr gets the
file system specification into a local variable of type FSSpec.  This file system specification
is then passed in the first parameter of a call to FSpGetFInfo, allowing the file type to be
ascertained.  The file system specification and file type are then passed in a call to the
function doOpenFile, which creates a new window and reads in the file.

If the user clicked the Save button in a Save Location dialog, the window reference received in
the callBackUD formal parameter is assigned to the local variable windowRef.  (Recall that the
window reference for the front window was passed in the fifth parameter of the call to
NavCreatePutFileDialog.)  The next task is to determine which of the two file saving functions
(doSaveUsingFSSpec or doSaveUsingFSRef) should be called to save the file.  Accordingly,
AECoerceDesc is called in an attempt to coerce the descriptor structure in the selection field
of the NavReplyRecord structure to type FSRef.  If the call is successful, doSaveUsingFSRef is
called; if not, doSaveUsingFSSpec is called.

If the user clicked the Choose button in a Choose a Folder dialog, AEGetNthPtr is called to get
the file system specification into a local variable of type FSSpec.  When a file system
specification describes a directory, as it does in this case, the name field is empty and the
parID field contains the directory ID of that directory, not the ID of the parent directory. 
In this demonstration, the volume reference number and directory ID are passed in a call to
FSMakeFSSpec, which fills in the fields of the FSSpec record pointed to by the fourth
parameter.  The contents of the fields of this FSSpec structure (the directory name, its parent
directory ID, and the volume reference number) are then drawn in the bottom of the front
window.

Before exit from the kNavCBUserAction case, NavDisposeReply is called to release the memory
allocated for the NavReplyRecord structure.

When the user has clicked a dialog's Cancel button, the kNavCBTerminate message is received in
the callBackSelector formal parameter.  When this message is received, if a dialog reference
has been assigned to the global variable gModalToApplicationNavDialogRef (as it will be in the
case of the application-modal Open and Choose a Folder dialogs), the dialog is disposed of and
the global variable is assigned NULL.  If gModalToApplicationNavDialogRef contains NULL, the
window reference received in the callBackUD formal parameter is assigned to the local variable
windowRef.  (Recall that the window reference for the front window was passed in the fifth
parameter of the call to NavCreatePutFileDialog.)  A handle to the window's document structure
is then retrieved, allowing access to the dialog reference stored in that structure.  The
dialog is disposed of and the relevant field of the document structure is assigned NULL.

Note that, in Carbon applications, there is no need to respond to the kNavCBEvent message in
this event function or the following event function in order to call the application's window
updating function.  This is assuming the standard window event handler is installed on the
relevant windows, the application registers for the kEventWindowDrawContent event type, and
calls its window updating function when that event type is received.  The following example is
provided for those circumstances in which these conditions are not met:

     case kNavCBEvent:
       switch(callBackParms->eventData.eventDataParms.event->what)
       {
         case updateEvt:
           windowRef = (WindowRef) callBackParms->eventData.eventDataParms.event->message;
           if(GetWindowKind(windowRef) != kDialogWindowKind)
             doUpdate((EventRecord *) callBackParms->eventData.eventDataParms.event);
           break;
       }
       break;

askSaveDiscardEventFunction

askSaveDiscardEventFunction is the event (callback) function pertaining to the Save Changes and
Discard Changes alerts.  It responds to button clicks in those dialogs.

When the user has clicked one of the dialog's buttons, the kNavCBUserAction message is received
in the callBackSelector formal parameter.  When this message is received, the first action is
to get a handle to the front window's document structure.  (Recall that the reference to the
front window was passed in the third parameter of the NavCreateAskSaveChangesDialog and
NavCreateAskDiscardChangesDialog calls.)  The main if block executes only if the
modalToWindowNavDialogRef field of the document structure contains a dialog reference.

If the user clicked the Save button in a Save Changes alert, doSaveCommand is called to save
the file and execution falls through to the kNavUserActionDontSaveChanges case where
doCloseDocWindow is called to close the file, flush the volume, and close down the window.  

If the user clicked the Don't Save button in a Save Changes alert, and if the program is 
running on Mac OS X, doCloseDocWindow is called to close the file, flush the volume, and 
close down the window.  If the program is running on Mac OS 9, the global variable 
gCloseDocWindow is set to true, causing the doCloseDocWindow call to occur in the function 
doCreateAskSaveChangesDialog.  Before all this occurs, NavDialogDispose is called to dispose 
of the alert before the window is closed by the call to doCloseDocWindow.

If the user clicked the OK button in a Discard Changes alert, the window's content area is
erased and the appropriate function (doReadTextFile or doReadPictFile) is called depending on
whether the file type is 'TEXT' or 'PICT'.  In addition, the window's "touched" field in the
document structure is set to false and InvalWindowRect is called to force a redraw of the
window's content region.  Just before the InvalWindowRect call, SetWindowModified is called
with false passed in the modified parameter.  This causes the window proxy icon to appear in
the enabled state, indicating no unsaved changes.  The Discard Changes alert is then disposed
of.

If the user clicked the Cancel button in a Save Changes or Discard Changes alert, and if it is
a Save Changes alert, the flag gQuittingApplication is set to false.  This has the effect of
defeating the execution of the last block of code in the function doCloseDocWindow.  (Recall
that the isAskSaveChangesDialog field of the window's document structure is set to true when
such alerts are created.)  The alert is then disposed of.

doCopyResources

doCopyResources is called by doWriteFile.  It copies the missing application name string
resource from the resource fork of the application file to the resource fork of the new file. 
If the file type is PICT, a 'pnot' resource and associated 'PICT' resource is also copied.  If
the program is running on Mac OS 8/9 and the file type is TEXT, a 'pnot' resource, together
with a 'TEXT' resource created within the function, are also copied.  (For 'TEXT' files,
previews are automatically created on Mac OS X.)

The first line retrieves a handle to the file's document structure.  The next four lines
establish the file type involved.  FSpCreateResFile creates the resource fork in the new file
and FSpOpenResFile opens the resource fork.  The function for copying specified resources
between specified files (doCopyAResource) is then called to copy the missing application name
string resource from the resource fork of the application file to the resource fork of the new
file.

If the file type is 'PICT', a 'pnot' resource and associated 'PICT' resource is copied so as to
provide a preview for 'PICT' files in the Open dialog.  (Of course, in a real application, the
'pnot' and 'PICT' resource would be created by the application for each separate 'PICT' file.)

If the program is running on Mac OS 8/9 and the file type is 'TEXT', a 'pnot' resource is
copied and a 'TEXT' resource is created and copied so as to provide a a preview for 'TEXT'
files in the Open dialog.  After the 'pnot' resource is copied, a relocatable block is created
and 1024 bytes of the text in the TextEdit structure is copied to that block.  AddResource
turns that arbitrary data in memory into a 'TEXT' resource, assigns a resource type, ID, and
name to that resource, and inserts an entry in the resource map for the current resource file
(in this case, the resource fork of the TEXT file).  UpdateResFile then writes the resource map
and data to disk.

CloseResFile closes the resource fork of the new file.

doCopyAResource

doCopyAResource copies specified resources between specified files.  In this program, it is
called only by doCopyResources.

UseResFile sets the application's resource fork as the current resource file.  GetResource
reads the specified resource into memory.

GetResInfo, given a handle, gets the resource type, ID and name.  (Note that this line is
included only because of the generic nature of doCopyResource.  The calling function has passed
doCopyResource the type and ID in this instance.)

DetachResource removes the resource's handle from the resource map without removing the
resource from memory, and converts the resource handle into a generic handle.  UseResFile makes
the new file's resource fork the current resource file.  AddResource makes the now arbitrary
data in memory into a resource, assigns a resource ID, type and name to that resource, and
inserts an entry in the resource map for the current resource file.  UpdateResFile then writes
the resource map and data to disk.

SynchroniseFiles.c

doSynchroniseFiles

doSynchroniseFiles is called from doIdle when the installed timer fires (every 15 ticks when a
document window is the front window).

A reference to the front non-floating window is obtained.  The while loop walks the document
window section of the window list (see the call to GetNextWindow at the bottom of the loop)
looking for associated files whose locations have changed.  When the last window in the list
has been examined, the loop exits.

Within the while loop, GetWRefCon is called to retrieve the handle to the window's document
structure.

If the aliasHdl field of the window's document structure contains NULL, the window does not yet
have a file associated with it, in which case execution falls through to the next iteration of
the while loop and the next window is examined.

If the window has an associated file, the handle to the associated alias structure, which
contains the alias data for the file, is retrieved.  ResolveAlias is then called to perform a
search for the target of the alias, returning the file system specification for the target file
in the third parameter.  After identifying the target, ResolveAlias compares some key
information about the target with the information in the alias structure.  If the information
differs, ResolveAlias updates the alias structure to match the target and sets the aliasChanged
parameter to true.

If the aliasChanged parameter is set to true, meaning that the location of the file has
changed, the fileFSSpec field of the window's document structure is assigned the file system
specification structure returned by ResolveAlias.  Since it is also possible that the user has
renamed the file, SetWTitle is called to set the window's title to the filename contained in
the name field of the file system specification structure returned by ResolveAlias.

The next task is to determine whether the user has moved the file to the trash or to a folder
in the trash, in which case the document must be closed.  

FindFolder is called to get the volume reference number and parent directory ID of the trash
folder.  (Note that kUserDomain is passed in the vRefNum parameter.  On Mac OS 8/9, this is
mapped to kOnSystemDisk.)

The do/while loop walks up the parent folder hierarchy to the root folder.  At the first line
in the do/while loop, if the root folder has been reached (fsRtParID is the parent ID of the
root directory), the file is not in the trash, in which case the loop exits at that point.  At
the next if statement, the volume reference number and parent directory ID of the file are
compared with the volume reference number and directory ID of the trash.  If they match, the
file is closed, its associated memory is disposed of, and the window is disposed of.

The bottom line of the do/while loop effects the walk up the parent directory hierarchy,
FSMakeFSSpec creates a file system specification structure from the current contents of the
vRefNum and parID fields of newFSSPec.  Since newFSSpec is also the target, the parID field is
"filled in" again, at every iteration of the loop, with the parent ID of the directory passed
in the second parameter of the FSMakeFSSpec call.

ChooseAFolderDialog.c

doChooseAFolderDialog

doChooseAFolderDialog, which is called when the user chooses the Choose a Folder Dialog item in
the demonstration menu, creates and displays a Choose a Folder dialog.

NavGetDefaultDialogCreationOptions initialises the specified NavDialogCreation Options
structure with the defaults.  GetIndString retrieves a Pascal string, which is converted to a
CFString and assigned to the message field of a NavDialogOptions structure.  This will appear
immediately below the browser list in the Mac OS 8/9 dialog and above the browser list in the
Mac OS X dialog.

The next line ensures that the dialog will be application-modal.

NavCreateChooseFolderDialog creates the dialog and NavDialogRun displays it.
 
AAPL
$102.50
Apple Inc.
+0.25
MSFT
$45.43
Microsoft Corpora
+0.55
GOOG
$571.60
Google Inc.
+2.40

MacTech Search:
Community Search:

Software Updates via MacUpdate

Skype 6.19.0.450 - Voice-over-internet p...
Skype allows you to talk to friends, family and co-workers across the Internet without the inconvenience of long distance telephone charges. Using peer-to-peer data transmission technology, Skype... Read more
VueScan 9.4.41 - Scanner software with a...
VueScan is a scanning program that works with most high-quality flatbed and film scanners to produce scans that have excellent color fidelity and color balance. VueScan is easy to use, and has... Read more
Cloud 3.0.0 - File sharing from your men...
Cloud is simple file sharing for the Mac. Drag a file from your Mac to the CloudApp icon in the menubar and we take care of the rest. A link to the file will automatically be copied to your clipboard... Read more
LibreOffice 4.3.1.2 - Free Open Source o...
LibreOffice is an office suite (word processor, spreadsheet, presentations, drawing tool) compatible with other major office suites. The Document Foundation is coordinating development and... Read more
SlingPlayer Plugin 3.3.20.505 - Browser...
SlingPlayer is the screen interface software that works hand-in-hand with the hardware inside the Slingbox to make your TV viewing experience just like that at home. It features an array of... Read more
Get Lyrical 3.8 - Auto-magically adds ly...
Get Lyrical auto-magically add lyrics to songs in iTunes. You can choose either a selection of tracks, or the current track. Or turn on "Active Tagging" to get lyrics for songs as you play them.... Read more
Viber 4.2.2 - Send messages and make cal...
Viber lets you send free messages and make free calls to other Viber users, on any device and network, in any country! Viber syncs your contacts, messages and call history with your mobile device,... Read more
Cocktail 7.6 - General maintenance and o...
Cocktail is a general purpose utility for OS X that lets you clean, repair and optimize your Mac. It is a powerful digital toolset that helps hundreds of thousands of Mac users around the world get... Read more
LaunchBar 6.1 - Powerful file/URL/email...
LaunchBar is an award-winning productivity utility that offers an amazingly intuitive and efficient way to search and access any kind of information stored on your computer or on the Web. It provides... Read more
Maya 2015 - Professional 3D modeling and...
Maya is an award-winning software and powerful, integrated 3D modeling, animation, visual effects, and rendering solution. Because Maya is based on an open architecture, all your work can be scripted... Read more

Latest Forum Discussions

See All

Rhonna Designs Magic (Photography)
Rhonna Designs Magic 1.0 Device: iOS Universal Category: Photography Price: $1.99, Version: 1.0 (iTunes) Description: Want to sprinkle *magic* on your photos? With RD Magic, you can add colors, filters, light leaks, bokeh, edges,... | Read more »
This Week at 148Apps: August 25-29, 2014
Shiny Happy App Reviews   | Read more »
Qube Kingdom – Tips, Tricks, Strategies,...
Qube Kingdom is a tower defense game from DeNA. You rally your troops – magicians, archers, knights, barbarians, and others – and fight against an evil menace looking to dominate your kingdom of tiny squares. Planning a war isn’t easy, so here are a... | Read more »
Qube Kingdom Review
Qube Kingdom Review By Nadia Oxford on August 29th, 2014 Our Rating: :: KIND OF A SQUARE KINGDOMUniversal App - Designed for iPhone and iPad Qube Kingdom has cute visuals, but it’s a pretty basic tower defense game at heart.   | Read more »
Fire in the Hole Review
Fire in the Hole Review By Rob Thomas on August 29th, 2014 Our Rating: :: WALK THE PLANKUniversal App - Designed for iPhone and iPad Seafoam’s Fire in the Hole looks like a bright, 8-bit throwback, but there’s not enough booty to... | Read more »
Alien Creeps TD is Now Available Worldwi...
Alien Creeps TD is Now Available Worldwide Posted by Ellis Spice on August 29th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Dodo Master Review
Dodo Master Review By Jordan Minor on August 29th, 2014 Our Rating: :: NEST EGGiPad Only App - Designed for the iPad Dodo Master is tough but fair, and that’s what makes it a joy to play.   | Read more »
Motorsport Manager Review
Motorsport Manager Review By Lee Hamlet on August 29th, 2014 Our Rating: :: MARVELOUS MANAGEMENTUniversal App - Designed for iPhone and iPad Despite its depth and sense of tactical freedom, Motorsport Manager is one of the most... | Read more »
Motorsport Manager – Beginner Tips, Tric...
The world of Motorsport management can be an unforgiving and merciless one, so to help with some of the stress that comes with running a successful race team, here are a few hints and tips to leave your opponents in the dust. | Read more »
CalPal Update Brings the App to 2.0, Add...
CalPal Update Brings the App to 2.0, Adds Lots of New Stuff Posted by Ellis Spice on August 29th, 2014 [ permalink ] | Read more »

Price Scanner via MacPrices.net

Apple now offering refurbished 21-inch 1.4GHz...
The Apple Store is now offering Apple Certified Refurbished 21″ 1.4GHz iMacs for $929 including free shipping plus Apple’s standard one-year warranty. Their price is $170 off the cost of new models,... Read more
Save $50 on the 2.5GHz Mac mini, on sale for...
B&H Photo has the 2.5GHz Mac mini on sale for $549.99 including free shipping. That’s $50 off MSRP, and B&H will also include a free copy of Parallels Desktop software. NY sales tax only. Read more
Save up to $300 on an iMac with Apple refurbi...
The Apple Store has Apple Certified Refurbished iMacs available for up to $300 off the cost of new models. Apple’s one-year warranty is standard, and shipping is free. These are the best prices on... Read more
The Rise of Phablets
Carlisle & Gallagher Consulting Group, a businesses and technology consulting firm focused solely on the financial services industry, has released an infographic depicting the convergence of... Read more
Bad Driver Database App Allows Good Drivers t...
Bad Driver Database 1.4 by Facile Group is a new iOS and Android app that lets users instantly input and see how many times a careless, reckless or just plain stupid driver has been added to the... Read more
Eddy – Cloud Music Player for iPhone/iPad Fre...
Ukraine based CapableBits announces the release of Eddy, its tiny, but smart and powerful cloud music player for iPhone and iPad that allows users to stream or download music directly from cloud... Read more
A&D Medical Launches Its WellnessConnecte...
For consumers and the healthcare providers and loved ones who care for them, A&D Medical, a leader in connected health and biometric measurement devices and services, has launched its... Read more
Anand Lal Shimpi Retires From AnandTech
Anand Lal Shimpi, whose AnandTech Website is famous for its meticulously detailed and thoroughgoing reviews and analysis, is packing it in. Lal Shimpi, who founded the tech site at age 14 in 1997,... Read more
2.5GHz Mac mini, Apple refurbished, in stock...
The Apple Store has Apple Certified Refurbished 2.5GHz Mac minis available for $509, $90 off MSRP. Apple’s one-year warranty is included, and shipping is free. Read more
13-inch 2.5GHz MacBook Pro on sale for $999,...
B&H Photo has the 13″ 2.5GHz MacBook Pro on sale for $999.99 including free shipping plus NY sales tax only. Their price is $100 off MSRP. Read more

Jobs Board

*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
Senior Event Manager, *Apple* Retail Market...
…This senior level position is responsible for leading and imagining the Apple Retail Team's global event strategy. Delivering an overarching brand story; in-store, Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.