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