home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / MacPerl 5.1.3 / Mac_Perl_513_src / MacPerl5 / MPFile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-18  |  20.1 KB  |  903 lines  |  [TEXT/MPS ]
  1. /*********************************************************************
  2. Project    :    MacPerl            -    Real Perl Application
  3. File        :    MPFile.c            -
  4. Author    :    Matthias Neeracher
  5.  
  6. A lot of this code is borrowed from 7Edit written by
  7. Apple Developer Support UK
  8.  
  9. Language    :    MPW C
  10.  
  11. $Log: MPFile.c,v $
  12. Revision 1.1  1994/02/27  23:00:47  neeri
  13. Initial revision
  14.  
  15. Revision 0.6  1993/09/17  00:00:00  neeri
  16. Runtime version
  17.  
  18. Revision 0.5  1993/08/28  00:00:00  neeri
  19. Handle multiple preference files
  20.  
  21. Revision 0.4  1993/08/17  00:00:00  neeri
  22. Enable Save
  23.  
  24. Revision 0.3  1993/08/13  00:00:00  neeri
  25. Write bounds rectangles
  26.  
  27. Revision 0.2  1993/05/30  00:00:00  neeri
  28. Support Console Windows
  29.  
  30. Revision 0.1  1993/05/29  00:00:00  neeri
  31. Compiles correctly
  32.  
  33. *********************************************************************/
  34.  
  35. #include <Errors.h>
  36. #include <Resources.h>
  37. #include <Desk.h>
  38. #include <PLStringFuncs.h>
  39. #include <AppleEvents.h>
  40. #include <AERegistry.h>
  41. #include <StandardFile.h>
  42. #include <TFileSpec.h>
  43. #include <Balloons.h>
  44.  
  45. #include "MPFile.h"
  46. #include "MPScript.h"
  47. #include "MPSave.h"
  48. #include "MPEditor.h"
  49. #include "MPPreferences.h"
  50.  
  51. /**-----------------------------------------------------------------------
  52.         Name:             FileError
  53.         Purpose:        Puts up an error alert.
  54.     -----------------------------------------------------------------------**/
  55.  
  56.  
  57. #if !defined(powerc) && !defined(__powerc)
  58. #pragma segment File
  59. #endif
  60.  
  61. pascal void FileError(Str255 s, Str255 f)
  62. {
  63.     SetCursor(&qd.arrow);
  64.     ParamText(s, f, (StringPtr) "\p", (StringPtr) "\p");
  65.      Alert(ErrorAlert, nil);
  66. }
  67.  
  68. /**-----------------------------------------------------------------------
  69.         Name:             DoClose
  70.         Purpose:        Closes a window.
  71.     -----------------------------------------------------------------------**/
  72.  
  73. #if !defined(powerc) && !defined(__powerc)
  74. #pragma segment File
  75. #endif
  76.  
  77. pascal OSErr DoClose(WindowPtr aWindow, Boolean canInteract, DescType dialogAnswer)
  78. {
  79.      DPtr    aDocument;
  80.      short   alertResult;
  81.      Str255  theName;
  82.     OSErr   myErr;
  83.  
  84.     myErr = noErr;
  85.  
  86.      if (gWCount > 0) {
  87.         aDocument = DPtrFromWindowPtr(aWindow);
  88.  
  89.         if (aDocument->kind == kDocumentWindow) {
  90.             if (aDocument->dirty)
  91.                 if (canInteract && (dialogAnswer==kAEAsk)) {
  92.                     if (aDocument->u.reg.everSaved == false)
  93.                         GetWTitle(aWindow, theName); /* Pick it up as a script may have changed it */
  94.                     else
  95.                         PLstrcpy(theName, aDocument->theFileName);
  96.     
  97.                     ParamText(theName, (StringPtr) "\p", (StringPtr) "\p", (StringPtr) "\p");
  98.                     SetCursor(&qd.arrow);
  99.                     alertResult = Alert(SaveAlert, nil);
  100.                     switch (alertResult) {
  101.                     case aaSave:
  102.                         myErr = SaveAskingName(aDocument, canInteract);
  103.                         break;
  104.     
  105.                     case aaCancel:
  106.                         return userCanceledErr;
  107.     
  108.                     case aaDiscard:
  109.                         aDocument->dirty = false;
  110.                         break;
  111.                     }
  112.                 } else {
  113.                     if (dialogAnswer==kAEYes)
  114.                         myErr = SaveAskingName(aDocument, canInteract);
  115.                     else
  116.                         myErr = noErr; /* Don't save */
  117.                 }
  118.                 
  119.             if (!myErr) {
  120. #ifdef EVIL_USELESS_EDITIONS
  121.                 if (aDocument->kind == kDocumentWindow && aDocument->u.reg.numSections)
  122.                     DeRegisterAllSections(aDocument);
  123. #endif
  124.  
  125.                 CloseMyWindow(aWindow);
  126.             }
  127.         } else if (aDocument->u.cons.selected) {
  128.             if (!gQuitting) {
  129.                 SysBeep(0);
  130.     
  131.                 return userCanceledErr;
  132.             }
  133.         } else 
  134.             SaveConsole(aDocument);
  135.     } else
  136.         myErr = errAEIllegalIndex;
  137.  
  138.     return myErr;
  139. }
  140.  
  141. #if !defined(powerc) && !defined(__powerc)
  142. #pragma segment File
  143. #endif
  144.  
  145. //  DoQuit
  146. //  saveOpt - one of kAEAsk,kAEYes,kAENo
  147. //  if kAEYes or kAEAsk then AEInteactWithUser should have been called
  148. //  before DoQuit. Assumes that it can interact if it needs to.
  149.  
  150. pascal void DoQuit(DescType saveOpt)
  151. {
  152.     WindowPtr    aWindow;
  153.     WindowPtr    nextWindow;
  154.     short            theKind;
  155.  
  156.     if (gRunningPerl && (Alert(AbortAlert, nil) == 2))
  157.         return;
  158.         
  159.     gQuitting = true;
  160.  
  161.     for (aWindow = FrontWindow(); aWindow; aWindow = nextWindow) {
  162.         nextWindow = GetNextWindow(aWindow);
  163.         if (Ours((WindowPtr) aWindow)) {
  164.             if (DoClose((WindowPtr) aWindow, true, saveOpt)) {
  165.                 gQuitting = false;
  166.                 
  167.                 return;
  168.             }
  169.         } else {
  170.             theKind = GetWindowKind(aWindow);
  171.             if (theKind < 0)
  172.                 CloseDeskAcc(theKind);
  173.         }
  174.     }
  175. }
  176.  
  177. pascal Boolean GetFileFilter(CInfoPBPtr pb)
  178. {
  179.     switch (GetDocTypeFromInfo(pb)) {
  180.     case kPreferenceDoc:
  181.         /* We don't want preference files here. Maybe we should */
  182.     case kUnknownDoc:
  183.         return true;
  184.     default:
  185.         return false;
  186.     }
  187. }
  188.  
  189. #if USESROUTINEDESCRIPTORS
  190. RoutineDescriptor    uGetFileFilter = 
  191.         BUILD_ROUTINE_DESCRIPTOR(uppFileFilterProcInfo, GetFileFilter);
  192. #else
  193. #define uGetFileFilter *(FileFilterUPP)&GetFileFilter
  194. #endif
  195.  
  196. pascal OSErr GetFile(FSSpec *theFSSpec)
  197. {
  198.     StandardFileReply  reply;
  199.  
  200.     BuildSEList();
  201.     
  202.     StandardGetFile(&uGetFileFilter, MacPerlFileTypeCount, MacPerlFileTypes, &reply);
  203.  
  204.     if (reply.sfGood) {
  205.         *theFSSpec = reply.sfFile;
  206.         return noErr;
  207.     } else
  208.         return userCanceledErr;
  209. }
  210.  
  211. #if !defined(powerc) && !defined(__powerc)
  212. #pragma segment File
  213. #endif
  214.  
  215. pascal OSErr DoCreate(FSSpec theSpec)
  216. {
  217.     OSErr err;
  218.  
  219.     err = FSpCreate(&theSpec, MPAppSig, 'TEXT', smSystemScript);
  220.  
  221.     if (!err)
  222.         HCreateResFile(theSpec.vRefNum, theSpec.parID, theSpec.name);
  223.     else
  224.         ShowError((StringPtr) "\pCreating", err);
  225.  
  226.     return err;
  227. }
  228.  
  229. pascal OSErr SaveConsole(DPtr doc)
  230. {
  231.     OSErr            err;
  232.     short       resFile;
  233.     HHandle     theHHandle;
  234.     Str255        title;
  235.     Boolean        existing;
  236.     
  237.     resFile    =    CurResFile();
  238.     
  239.     OpenPreferences();
  240.     if (gPrefsFile) {
  241.         UseResFile(gPrefsFile);
  242.         GetWTitle(doc->theWindow, title);
  243.         
  244.         if (theHHandle = (HHandle) Get1NamedResource('TFSS', title)) {
  245.             existing = true;
  246.         } else {
  247.             existing = false;
  248.             theHHandle = (HHandle)NewHandle(sizeof(HeaderRec));
  249.         }
  250.         
  251.         HLock((Handle)theHHandle);
  252.     
  253.         (*theHHandle)->theRect     = doc->theWindow->portRect;
  254.         OffsetRect(
  255.             &(*theHHandle)->theRect,
  256.             -doc->theWindow->portBits.bounds.left,
  257.             -doc->theWindow->portBits.bounds.top);
  258.             
  259.         GetFontName((*(doc->theText))->txFont, (StringPtr) &(*theHHandle)->theFont);
  260.         
  261.         (*theHHandle)->theSize     = (*(doc->theText))->txSize;
  262.         (*theHHandle)->lastID      = 0;
  263.         (*theHHandle)->numSections = 0;
  264.     
  265.         HUnlock((Handle)theHHandle);
  266.     
  267.         if (existing) {
  268.             ChangedResource((Handle) theHHandle);
  269.             WriteResource((Handle) theHHandle);
  270.             UpdateResFile(gPrefsFile);
  271.         } else {
  272.             AddResource((Handle)theHHandle, 'TFSS', Unique1ID('TFSS'), title);
  273.         }
  274.         
  275.         err = ResError();
  276.         
  277.         CloseResFile(gPrefsFile);
  278.         UseResFile(resFile);
  279.     }
  280.     
  281.     if (doc->u.cons.cookie) {
  282.         /* We might need this window again. */
  283.         DoHideWindow(doc->theWindow);
  284.         TESetSelect(0, 32767, doc->theText);
  285.         TEDelete(doc->theText);
  286.     
  287.         if (doc->u.cons.fence < 32767)
  288.             doc->u.cons.fence    = 0;
  289.     } else /* Done with this window */
  290.         CloseMyWindow(doc->theWindow);
  291.     
  292.     return err;
  293. } 
  294.  
  295. pascal void ApplySettings(DPtr doc, HPtr settings)
  296. {
  297.     short        fNum;
  298.     FontInfo    info;
  299.     Rect        bounds;
  300.     
  301.     GetFNum(settings->theFont, &fNum);
  302.     SetPort(doc->theWindow);
  303.     TextFont(fNum);
  304.     TextSize(settings->theSize);
  305.     GetFontInfo(&info);
  306.     
  307.     (*doc->theText)->txFont         = fNum;
  308.     (*doc->theText)->txSize         = settings->theSize;
  309.     (*doc->theText)->lineHeight    = info.ascent+info.descent+info.leading;
  310.     (*doc->theText)->fontAscent    = info.ascent;
  311.     
  312.     bounds.top                            = settings->theRect.top - 13;
  313.     bounds.left                            = settings->theRect.left + 5;
  314.     bounds.bottom                        = settings->theRect.top  - 5;
  315.     bounds.right                        = settings->theRect.right - 5;
  316.     
  317.     if (settings->theRect.right > settings->theRect.left + 50 &&
  318.         settings->theRect.bottom > settings->theRect.top  + 50 &&
  319.         RectInRgn(&bounds, GetGrayRgn())
  320.     ) {
  321.         MoveWindow(doc->theWindow, settings->theRect.left, settings->theRect.top, false);
  322.         SizeWindow(
  323.             doc->theWindow,
  324.             settings->theRect.right - settings->theRect.left,
  325.             settings->theRect.bottom - settings->theRect.top,
  326.             false);
  327.     }
  328.         
  329.     ResizeWindow(doc);
  330. }
  331.  
  332. pascal void RestoreConsole(DPtr doc)
  333. {
  334.     short       resFile;
  335.     HHandle     theHHandle;
  336.     Str255        title;
  337.     
  338.     resFile    =    CurResFile();
  339.     OpenPreferences();
  340.     if (!gPrefsFile)
  341.         return;
  342.         
  343.     UseResFile(gPrefsFile);
  344.     GetWTitle(doc->theWindow, title);
  345.     
  346.     if (theHHandle = (HHandle) Get1NamedResource('TFSS', title)) {
  347.          HLock((Handle)theHHandle);
  348.         
  349.         ApplySettings(doc, *theHHandle);
  350.         
  351.         HUnlock((Handle)theHHandle);
  352.     }
  353.     
  354.     CloseResFile(gPrefsFile);
  355.     UseResFile(resFile);
  356. }
  357.  
  358.  
  359. /** -----------------------------------------------------------------------
  360.         Name:         GetFileContents
  361.         Purpose:        Opens the document specified by theFSSpec and puts
  362.                         the contents into theDocument.
  363.      -----------------------------------------------------------------------**/
  364.  
  365. #if !defined(powerc) && !defined(__powerc)
  366. #pragma segment File
  367. #endif
  368.  
  369. pascal OSErr GetFileContents(FSSpec spec, DPtr theDocument)
  370. {
  371.     long            theSize;
  372.     short            oldRes;
  373.     short            resFile;
  374.     short            refNum;
  375.     OSErr            err;
  376.     HHandle        aHandle;
  377.     Handle        gHandle;
  378.  
  379.     oldRes    =    CurResFile();
  380.     resFile     =    HOpenResFile(spec.vRefNum, spec.parID, spec.name, fsRdPerm);
  381.     
  382.     theDocument->u.reg.everLoaded = true;
  383.     theDocument->u.reg.origFSSpec = spec;
  384.     
  385.     if (theDocument->inDataFork) {
  386.         if (err = HOpenDF(spec.vRefNum, spec.parID, spec.name, fsRdPerm, &refNum)) {
  387.             ShowError((StringPtr) "\pread file - HOpenDF", err);
  388.             refNum = 0;
  389.             
  390.             goto giveUp;
  391.         }
  392.     
  393.         if (err = GetEOF(refNum, &theSize))
  394.             goto giveUp;
  395.  
  396.           gHandle = NewHandle(theSize);
  397.  
  398.         HLock(gHandle);
  399.         if (err = FSRead(refNum, &theSize, *gHandle))
  400.             return err;
  401.         HUnlock(gHandle);
  402.         FSClose(refNum);
  403.     } else {
  404.         gHandle    =    Get1NamedResource('TEXT', (StringPtr) "\p!");
  405.         
  406.         if (gHandle) 
  407.             DetachResource(gHandle);
  408.         else {
  409.             err = ResError();
  410.             
  411.             goto giveUp;
  412.         }
  413.     }
  414.  
  415. #ifdef EVIL_USELESS_EDITIONS
  416.     theDocument->u.reg.numSections = 0;
  417. #endif
  418.  
  419.     if (resFile != -1) {
  420.         aHandle = nil;
  421.  
  422.         if (Count1Resources('TFSS'))
  423.             aHandle = (HHandle)Get1Resource('TFSS', 255);
  424.  
  425.         if (aHandle) {
  426. #ifdef EVIL_USELESS_EDITIONS
  427.             theDocument->u.reg.numSections = (*aHandle)->numSections;
  428. #endif
  429.  
  430.             HLock((Handle) aHandle);
  431.             ApplySettings(theDocument, *aHandle);
  432.         }
  433.  
  434.         /*
  435.             If there is a print record saved, ditch the old one
  436.             created by new document and fill this one in
  437.         */
  438.         if (Count1Resources('TFSP')) {
  439.             if (theDocument->thePrintSetup)
  440.                 DisposHandle((Handle)theDocument->thePrintSetup);
  441.  
  442.             theDocument->thePrintSetup = (THPrint)Get1Resource('TFSP', 255);
  443.               HandToHand((Handle *)&theDocument->thePrintSetup);
  444.  
  445.             PrOpen();
  446.             PrValidate(theDocument->thePrintSetup);
  447.             PrClose();
  448.         }
  449.  
  450. #ifdef EVIL_USELESS_EDITIONS
  451.         if (theDocument->u.reg.numSections) {
  452.             ReadSectionRecords(theDocument);
  453.             ReadAllSectionResources(theDocument);
  454.         }
  455. #endif
  456.  
  457.         CloseResFile(resFile);
  458.  
  459.         if (err = ResError()) {
  460.             ShowError((StringPtr) "\pread file- CloseResFile", err);
  461.             return err;
  462.         }
  463.     }
  464.  
  465.     HLock(gHandle);
  466.     if (GetHandleSize(gHandle) > 32000) {
  467.         PtrToXHand(
  468.             *gHandle, 
  469.             (*theDocument->theText)->hText, 
  470.             GetHandleSize(gHandle));
  471.         
  472.         err = elvisErr;
  473.     } else
  474.         TESetText(*gHandle, GetHandleSize(gHandle), theDocument->theText);
  475.     DisposHandle(gHandle);
  476.  
  477.     if (err == fnfErr)
  478.         return noErr;
  479.     else
  480.           return err;
  481.  
  482. giveUp:    
  483.     if (refNum)
  484.         FSClose(refNum);
  485.         
  486.     if (resFile > -1)
  487.         CloseResFile(resFile);
  488.     
  489.     UseResFile(oldRes);
  490.     
  491.     return err;
  492. } /* GetFileContents */
  493.  
  494.  
  495. #if !defined(powerc) && !defined(__powerc)
  496. #pragma segment File
  497. #endif
  498.  
  499. pascal OSErr SaveAskingName(DPtr aDocument, Boolean canInteract)
  500. {
  501.     OSErr    myErr;
  502.  
  503.     if (aDocument->kind != kDocumentWindow || !aDocument->u.reg.everSaved) {
  504.  
  505.         if (canInteract) {
  506.             if (myErr = GetFileNameToSaveAs(aDocument))
  507.                 return myErr;
  508.  
  509.             if (myErr = SaveWithoutTemp(aDocument, aDocument->theFSSpec))
  510.                 return myErr;            
  511. #ifdef EVIL_USELESS_EDITIONS
  512.             AssocAllSections(aDocument);
  513. #endif
  514.             return noErr;
  515.         } else
  516.             return errAENoUserInteraction;
  517.  
  518.     } else
  519.         return SaveUsingTemp(aDocument);
  520. }
  521.  
  522. #if !defined(powerc) && !defined(__powerc)
  523. #pragma segment File
  524. #endif
  525.  
  526. void NukeFileProcess(FSSpec * spec)
  527. {
  528.     /* Search for process running with this file and quit it if necessary */
  529.     ProcessInfoRec         info;
  530.     FSSpec                    procSpec;
  531.     CInfoPBRec                specInfo;
  532.     AppleEvent                quitEvent;
  533.     AppleEvent                ignoreReply;
  534.     ProcessSerialNumber    psn;
  535.     
  536.     if (FSpCatInfo(spec, &specInfo))
  537.         return;
  538.         
  539.     psn.highLongOfPSN = 0;
  540.     psn.lowLongOfPSN  = kNoProcess;
  541.     while (!GetNextProcess(&psn))    {
  542.         info.processInfoLength     = sizeof(info);
  543.         info.processName             = nil;
  544.         info.processAppSpec         = &procSpec;
  545.         
  546.         if (GetProcessInformation(&psn, &info))
  547.             continue;
  548.         if (info.processSignature != specInfo.hFileInfo.ioFlFndrInfo.fdCreator)
  549.             continue;
  550.         if (!SameFSSpec(&procSpec, spec))
  551.             continue;
  552.         if(AEBuildAppleEvent(kCoreEventClass, kAEQuitApplication,
  553.                         typeProcessSerialNumber, &psn, sizeof(ProcessSerialNumber),
  554.                         0, 0, &quitEvent,
  555.                         ""))
  556.             return;
  557.         AESend(&quitEvent, &ignoreReply, 
  558.                  kAEWaitReply+kAENeverInteract, kAENormalPriority, kAEDefaultTimeout,
  559.                  nil, nil);
  560.         AEDisposeDesc(&quitEvent);
  561.         AEDisposeDesc(&ignoreReply);
  562.     }
  563. }
  564.  
  565. pascal OSErr SaveUsingTemp(DPtr theDocument)
  566. {
  567.     OSErr        err;
  568.     FSSpec    tempFSSpec;
  569.  
  570.     /*save the file to disk using a temporary file*/
  571.     /*this is the recommended way of doing things*/
  572.     /*first write out the file to disk using a temporary filename*/
  573.     /*if it is sucessfully written, exchange the temporary file with the last one saved*/
  574.     /*then delete the temporary file- so if anything goes wrong, the original version is still there*/
  575.     /*first generate the temporary filename*/
  576.  
  577.     GetTempFSSpec(theDocument, &tempFSSpec);
  578.  
  579.     if (err = DoCreate(tempFSSpec))
  580.         return err;
  581.  
  582.     if (err = DoSave(theDocument, tempFSSpec, theDocument->theFSSpec.name))
  583.         return err;
  584.     
  585.     NukeFileProcess(&theDocument->theFSSpec);
  586.     
  587.     if (err = FSpExchangeFiles(&tempFSSpec, &theDocument->theFSSpec))
  588.         return err;
  589.     
  590.     /*we've exchanged the files, now delete the temporary one*/
  591.  
  592.     FSpDelete(&tempFSSpec);
  593.     
  594.     if (!err && theDocument->kind == kDocumentWindow) {
  595.         theDocument->dirty                 = false;
  596.         theDocument->u.reg.everSaved     = true;
  597.         theDocument->u.reg.origFSSpec = theDocument->theFSSpec;
  598.     }
  599.  
  600.     return err;
  601. }
  602.  
  603. pascal OSErr SaveWithoutTemp(DPtr theDocument, FSSpec spec)
  604. {
  605.     OSErr        err;
  606.     
  607.     if (err = DoSave(theDocument, spec, spec.name))
  608.         return err;
  609.  
  610.     if (theDocument->kind == kDocumentWindow) {
  611.         theDocument->dirty                 = false;
  612.         theDocument->u.reg.everSaved     = true;
  613.         theDocument->u.reg.origFSSpec = theDocument->theFSSpec = spec;
  614.                 
  615.         SetWTitle(theDocument->theWindow, theDocument->theFSSpec.name);
  616.     }
  617.     /* Rebuild list of standard scripts */
  618.     AddStandardScripts();
  619.     
  620.     return noErr;
  621. }
  622.  
  623. #if !defined(powerc) && !defined(__powerc)
  624. #pragma segment File
  625. #endif
  626.  
  627. pascal short SaveScriptHook(short item, DialogPtr dlg, void * params)
  628. {
  629.     short                kind;
  630.     ControlHandle    type;
  631.     MenuHandle        typeMenu;
  632.     Rect                r;
  633.     DPtr                doc = (DPtr) params;
  634.     
  635.     if (GetWRefCon(dlg) != 'stdf')
  636.         return item;
  637.         
  638.     switch (item) {
  639.     case sfHookFirstCall:
  640.         GetDItem(dlg, ssd_Type, &kind, (Handle *) &type, &r);
  641.         typeMenu = (*(PopupPrivateDataHandle)(*type)->contrlData)->mHandle;
  642.         
  643.         AddExtensionsToMenu(typeMenu);
  644.         SetControlMaximum(type, CountMItems(typeMenu));
  645.         SetCtlValue(type, Type2Menu(doc->type));
  646.         
  647.         return sfHookFirstCall;
  648.     case ssd_Type:
  649.         GetDItem(dlg, item, &kind, (Handle *) &type, &r);
  650.         
  651.         doc->type = (DocType) Menu2Type(GetCtlValue(type));
  652.         
  653.         return sfHookNullEvent;
  654.     default:
  655.         return item;
  656.     }
  657. }
  658.  
  659. #if USESROUTINEDESCRIPTORS
  660. RoutineDescriptor    uSaveScriptHook = 
  661.         BUILD_ROUTINE_DESCRIPTOR(uppDlgHookYDProcInfo, SaveScriptHook);
  662. #else
  663. #define uSaveScriptHook *(DlgHookYDUPP)&SaveScriptHook
  664. #endif
  665.  
  666. /*
  667.     Fills in the document record with the user chosen destination
  668. */
  669.  
  670. pascal OSErr GetFileNameToSaveAs(DPtr theDocument)
  671. {
  672.     OSErr                    err;
  673.     StandardFileReply    reply;
  674.     Str255            suggestName;
  675.     Point                    where;
  676.     
  677.     where.h = where.v = -1;
  678.  
  679.     GetWTitle(theDocument->theWindow, suggestName);
  680.  
  681.     HMSetDialogResID(SaveScriptDialog);
  682.     CustomPutFile(
  683.         (StringPtr) "\pSave Document As:", suggestName, &reply,
  684.         SaveScriptDialog,
  685.         where,
  686.         &uSaveScriptHook,
  687.         (ModalFilterYDUPP) nil,
  688.         nil,
  689.         (ActivateYDUPP) nil,
  690.         theDocument);
  691.     HMSetDialogResID(-1);
  692.  
  693.     if (reply.sfGood)
  694.         switch (err = FSpDelete(&reply.sfFile)) {
  695.         case noErr:
  696.         case fnfErr:
  697.             theDocument->theFSSpec = reply.sfFile;
  698.             PLstrcpy(theDocument->theFileName, reply.sfFile.name);
  699.  
  700.             return noErr;
  701.         default:
  702.             return err;
  703.         }
  704.     else
  705.         return userCanceledErr;
  706. } /* GetFileNameToSaveAs */
  707.  
  708. #if !defined(powerc) && !defined(__powerc)
  709. #pragma segment File
  710. #endif
  711.  
  712. pascal DPtr MakeOldDoc(FSSpec aFSSpec, DocType type)
  713. {
  714.     DPtr          theDocument;
  715.     
  716.     theDocument = NewDocument(true, kDocumentWindow);
  717.  
  718.     SetWTitle(theDocument->theWindow, aFSSpec.name);
  719.  
  720.     SetPort(theDocument->theWindow);
  721.  
  722.     theDocument->theFSSpec   = aFSSpec;
  723.  
  724.     PLstrcpy(theDocument->theFileName, aFSSpec.name);
  725.  
  726.     theDocument->dirty               = false;
  727.     theDocument->inDataFork            = type == kPlainTextDoc;
  728.     
  729.     /* We *can* open documents created by unknown save extensions, but we can't
  730.        save them again 
  731.     */
  732.     if (CanSaveAs(type)) {
  733.         CInfoPBRec    info;
  734.  
  735.         theDocument->type                 = type;
  736.         if (!FSpCatInfo(&aFSSpec, &info) && info.hFileInfo.ioFlAttrib & 1)
  737.             theDocument->u.reg.everSaved    = false;        /* Locked file, don't overwrite */
  738.         else
  739.             theDocument->u.reg.everSaved    = true;
  740.     } else {
  741.         theDocument->type                    = kPlainTextDoc;
  742.         theDocument->u.reg.everSaved    = false;
  743.     }
  744.  
  745.     return theDocument;
  746. }
  747.  
  748. pascal OSErr OpenOld(FSSpec aFSSpec, DocType type)
  749. {
  750.     DPtr          theDocument;
  751.     OSErr         fileErr;
  752.     WindowPtr    win;
  753.  
  754.     if (win = AlreadyOpen(&aFSSpec, nil)) {
  755.         SelectWindow(win);
  756.         
  757.         return noErr;
  758.     }
  759.     
  760.     theDocument    =    MakeOldDoc(aFSSpec, type);
  761.     
  762.     fileErr = GetFileContents(aFSSpec, theDocument);
  763.  
  764.     if (!fileErr) {
  765.         ResizeWindow(theDocument);
  766.         DoShowWindow(theDocument->theWindow);
  767.     } else {
  768.         if (fileErr == elvisErr) {
  769.             theDocument->u.reg.everSaved    = false;
  770. #ifdef RUNTIME
  771.             if (AEInteractWithUser(kAEDefaultTimeout, nil, nil))
  772. #endif
  773.                 switch (Alert(gExternalEditor ? ElvisEditAlert : ElvisAlert, nil)) {
  774.                 case 1:
  775.                     SaveAskingName(theDocument, true);
  776.                     break;
  777.                 case 2:
  778.                     /* Abandon */
  779.                     break;
  780.                 case 3:
  781.                     /* Edit */
  782.                     EditExternal(&aFSSpec);
  783.                     break;
  784.                 }
  785.         } else
  786.             FileError((StringPtr) "\pError Opening ", aFSSpec.name);
  787.         
  788.         CloseMyWindow(theDocument->theWindow);
  789.     }
  790.  
  791.     return fileErr;
  792. } /* OpenOld */
  793.  
  794. pascal OSErr File2File(FSSpec aFSSpec, DocType type, FSSpec toFSSpec, DocType newtype)
  795. {
  796.     DPtr          theDocument;
  797.     OSErr         fileErr;
  798.  
  799.     theDocument    =    MakeOldDoc(aFSSpec, type);
  800.     
  801.     switch (fileErr = GetFileContents(aFSSpec, theDocument)) {
  802.     case elvisErr:
  803.         fileErr = noErr;
  804.         /* Fall through */
  805.     case noErr:
  806.         theDocument->type = newtype;
  807.         theDocument->u.reg.everSaved    = false;
  808.         if (SameFSSpec(&aFSSpec, &toFSSpec))
  809.             fileErr = SaveUsingTemp(theDocument);
  810.         else
  811.             fileErr = SaveWithoutTemp(theDocument, toFSSpec);
  812.         
  813.         /* Fall through */
  814.     default:
  815.         CloseMyWindow(theDocument->theWindow);
  816.     }
  817.  
  818.     return fileErr;
  819. } /* File2File */
  820.  
  821. pascal OSErr Handle2File(Handle text, FSSpec toFSSpec, DocType newtype)
  822. {
  823.     DPtr          theDocument;
  824.     OSErr         fileErr;
  825.  
  826.     theDocument = NewDocument(true, kDocumentWindow);
  827.     
  828.     HLock(text);
  829.     PtrToXHand(*text, (*theDocument->theText)->hText, GetHandleSize(text));
  830.     HUnlock(text);
  831.     
  832.     theDocument->u.reg.everSaved    = false;
  833.     theDocument->type                 = newtype;
  834.  
  835.     fileErr = SaveWithoutTemp(theDocument, toFSSpec);
  836.     
  837.     CloseMyWindow(theDocument->theWindow);
  838.  
  839.     return fileErr;
  840. } /* Handle2File */
  841.  
  842. pascal DocType GetDocTypeFromFile(short vRefNum, long dirID, StringPtr name)
  843. {
  844.     short            resFile;
  845.     short            nuFile;
  846.     OSType    **    rtType;
  847.     DocType        type    =    kUnknownDoc;
  848.     
  849.     resFile    = CurResFile();
  850.     nuFile    = HOpenResFile(vRefNum, dirID, name, fsRdPerm);
  851.     
  852.     if (nuFile != -1) {
  853.         if (rtType = (OSType **) Get1Resource('MrPL', 128))
  854.             type = **(DocType **) rtType;
  855.             
  856.         CloseResFile(nuFile);
  857.     }
  858.     UseResFile(resFile);
  859.     
  860.     return type;
  861. }
  862.  
  863. pascal DocType GetDocTypeFromInfo(CInfoPBPtr info)
  864. {
  865.     DocType        type    =    kUnknownDoc;
  866.     
  867.     switch (info->hFileInfo.ioFlFndrInfo.fdType) {
  868.     case 'APPL':
  869.         if (info->hFileInfo.ioFlFndrInfo.fdCreator == MPAppSig) 
  870.             /* A heuristic to separate old runtimes from PowerPC executables */
  871.             if (info->hFileInfo.ioFlLgLen && info->hFileInfo.ioFlLgLen < 100000)
  872.                 return kOldRuntime6Doc; 
  873.         
  874.         break;
  875.     case 'TEXT':
  876.         return kPlainTextDoc;
  877.     case 'pref':
  878.         switch (info->hFileInfo.ioFlFndrInfo.fdCreator) {
  879.         case MPAppSig:
  880.         case MPRtSig:
  881.             return kPreferenceDoc;
  882.         }
  883.         break;
  884.     default:
  885.         break;
  886.     }
  887.     
  888.     /* Ultimately, with save extensions, every file could be ours */
  889.     return GetDocTypeFromFile(
  890.         info->hFileInfo.ioVRefNum, 
  891.         info->hFileInfo.ioFlParID, 
  892.         info->hFileInfo.ioNamePtr);
  893. }
  894.  
  895. pascal DocType GetDocType(FSSpec * spec)
  896. {
  897.     CInfoPBRec    info;
  898.  
  899.     if (FSpCatInfo(spec, &info))
  900.         return kUnknownDoc;
  901.     else
  902.         return GetDocTypeFromInfo(&info);
  903. }