home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / MWCW Converter / main.c next >
Encoding:
C/C++ Source or Header  |  1997-07-05  |  22.9 KB  |  1,139 lines  |  [TEXT/CWIE]
  1. /*
  2.     A simple applet to strip DOS/Windoze LF's from text files and to change the type/creator to
  3.     the standard CodeWarrior 'TEXT'/'CWIE' types.
  4.     
  5.     Roy Wood, rrwood@execulink.com
  6. */
  7.  
  8.  
  9.  
  10. #include <stdio.h>
  11. #include <string.h>
  12. #include <stdlib.h>
  13.  
  14.  
  15.  
  16. //    Useful defines....
  17.  
  18. #define EQSTR                0
  19.  
  20. #define    errorDLOG            128
  21. #define progressDLOG        129
  22. #define kMWCWTEXTType        'TEXT'
  23. #define kMWCWCreatorType    'CWIE'
  24.  
  25. #define kTempFileName        "MWCW Converter Temp File"
  26.  
  27. #define kEnterChar            0x03
  28. #define kEscapeChar            0x1B
  29. #define kLFChar                0x0A
  30.  
  31.  
  32.  
  33. //    Function declarations
  34.  
  35. void main(void);
  36.  
  37.  
  38. static pascal void RestartProc(void);
  39.  
  40. static OSErr InstallOrRemoveAEHandlers(Boolean installAEHandlers,Boolean removeAEHandlers);
  41. static OSErr DoAEEvent(EventRecord *AERecord);
  42.  
  43. static pascal OSErr AEOpenHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  44. static pascal OSErr AEOpenDocHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  45. static pascal OSErr AEPrintHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  46. static pascal OSErr AEQuitHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  47.  
  48. static Boolean ProcessDialogCmdKey(DialogPtr theDPtr,EventRecord *theEvent,short *itemHit);
  49. static pascal Boolean MyDialogFilter(DialogPtr theDPtr,EventRecord *theEvent,short *itemHit);
  50. static void CenterWindow(WindowPtr wPtr);
  51. static pascal void HiliteDefaultButton(DialogPtr theDPtr,short whichItem);
  52. static void ErrorAlert(char *theErrorMessage);
  53.  
  54.  
  55.  
  56. //    Sort-of globals
  57.  
  58. static Boolean                    gAlive = true;
  59. static char                        gErrorMessage[512];
  60. static UserItemUPP                gMyHiliteDefaultButtonProc = nil;
  61. static ModalFilterUPP            gMyModalFilterProc = nil;
  62.  
  63.  
  64.  
  65.  
  66. //    Main-- install Apple Event handlers, check for pending Apple Events, then quit
  67.  
  68. void main(void)
  69. {
  70. EventRecord        theEvent;
  71.  
  72.  
  73.     InitGraf(&(qd.thePort));
  74.     InitFonts();
  75.     InitWindows();
  76.     InitMenus();
  77.     TEInit();
  78.     InitDialogs(RestartProc);
  79.     InitCursor();
  80.  
  81.     SetPort(qd.thePort);
  82.     
  83.  
  84.     if (InstallOrRemoveAEHandlers(true,false) != noErr)
  85.     {
  86.         ErrorAlert(gErrorMessage);
  87.         goto EXITPOINT;
  88.     }
  89.     
  90.     
  91.     while (GetNextEvent(highLevelEventMask,&theEvent))
  92.     {
  93.         if (theEvent.what == kHighLevelEvent)
  94.         {
  95.             if (DoAEEvent(&theEvent) != noErr)
  96.             {
  97.                 ErrorAlert(gErrorMessage);
  98.                 goto EXITPOINT;
  99.             }
  100.         }
  101.     }
  102.  
  103.  
  104.     while (WaitNextEvent(everyEvent,&theEvent,nil,nil))
  105.     {
  106.         switch (theEvent.what)
  107.         {
  108.             case kHighLevelEvent:
  109.                 if (DoAEEvent(&theEvent) != noErr)
  110.                 {
  111.                     ErrorAlert(gErrorMessage);
  112.                     goto EXITPOINT;
  113.                 }
  114.                 
  115.                 break;
  116.         }
  117.     }
  118.  
  119.  
  120.  
  121. EXITPOINT:
  122.  
  123.     if (InstallOrRemoveAEHandlers(false,true) != noErr)
  124.     {
  125.         ErrorAlert(gErrorMessage);
  126.     }
  127.     
  128.     return;
  129. }
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136. //    This is always nice to include....
  137.  
  138. static pascal void RestartProc(void)
  139. {
  140.     ExitToShell();
  141. }
  142.  
  143.  
  144.  
  145.  
  146.  
  147.  
  148.  
  149.  
  150.  
  151.  
  152.  
  153. //    Install Apple Event handlers
  154.  
  155. static OSErr InstallOrRemoveAEHandlers(Boolean installAEHandlers,Boolean removeAEHandlers)
  156. {
  157. OSErr                            errCode = noErr;
  158. Boolean                            doAEObjectInit = false;
  159. long                            aLong;
  160. static AEEventHandlerUPP        appleEventOpenUPP = nil;
  161. static AEEventHandlerUPP        appleEventOpenDocUPP = nil;
  162. static AEEventHandlerUPP        appleEventPrintUPP = nil;
  163. static AEEventHandlerUPP        appleEventQuitUPP = nil;
  164.  
  165.     
  166.     
  167.     errCode = Gestalt(gestaltAppleEventsAttr,&aLong);
  168.     
  169.     if (errCode != noErr)
  170.     {
  171.         sprintf(gErrorMessage,"InstallOrRemoveAEHandlers: Apple Events not supported, Gestalt(gestaltAppleEventsAttr) error %d",(int) errCode);
  172.         errCode = -1;
  173.         goto EXITPOINT;
  174.     }
  175.  
  176.     
  177.     if (installAEHandlers == true)
  178.     {
  179.         if (appleEventOpenUPP == nil)
  180.         {
  181.             doAEObjectInit = true;
  182.             
  183.             
  184.             appleEventOpenUPP = NewAEEventHandlerProc(AEOpenHandler);
  185.  
  186.             if (appleEventOpenUPP == nil)
  187.             {
  188.                 sprintf(gErrorMessage,"InstallOrRemoveAEHandlers: NewAEEventHandlerProc(AEOpenHandler) returned nil");
  189.                 errCode = -1;
  190.                 goto EXITPOINT;
  191.             }
  192.         
  193.             errCode = AEInstallEventHandler(kCoreEventClass,kAEOpenApplication,appleEventOpenUPP, 0, false);
  194.  
  195.             if (errCode != noErr) 
  196.             {
  197.                 sprintf(gErrorMessage,"InstallOrRemoveAEHandlers: AEInstallEventHandler(kAEOpenApplication) error %d",(int) errCode);
  198.                 errCode = -1;
  199.                 goto EXITPOINT;
  200.             }
  201.         }
  202.             
  203.         
  204.         
  205.         if (appleEventOpenDocUPP == nil)
  206.         {
  207.             doAEObjectInit = true;
  208.             
  209.             
  210.             appleEventOpenDocUPP = NewAEEventHandlerProc(AEOpenDocHandler);
  211.  
  212.             if (appleEventOpenDocUPP == nil)
  213.             {
  214.                 sprintf(gErrorMessage,"InstallOrRemoveAEHandlers: NewAEEventHandlerProc(AEOpenDocHandler) returned nil");
  215.                 errCode = -1;
  216.                 goto EXITPOINT;
  217.             }
  218.             
  219.             errCode = AEInstallEventHandler(kCoreEventClass,kAEOpenDocuments,appleEventOpenDocUPP, 0, false);
  220.  
  221.             if (errCode != noErr) 
  222.             {
  223.                 sprintf(gErrorMessage,"InstallOrRemoveAEHandlers: AEInstallEventHandler(kAEOpenDocuments) error %d",(int) errCode);
  224.                 errCode = -1;
  225.                 goto EXITPOINT;
  226.             }
  227.         }
  228.         
  229.         
  230.         
  231.         if (appleEventQuitUPP == nil)
  232.         {
  233.             doAEObjectInit = true;
  234.             
  235.             
  236.             appleEventQuitUPP = NewAEEventHandlerProc(AEQuitHandler);
  237.  
  238.             if (appleEventOpenDocUPP == nil)
  239.             {
  240.                 sprintf(gErrorMessage,"InstallOrRemoveAEHandlers: NewAEEventHandlerProc(AEQuitHandler) returned nil");
  241.                 errCode = -1;
  242.                 goto EXITPOINT;
  243.             }
  244.             
  245.             errCode = AEInstallEventHandler(kCoreEventClass,kAEQuitApplication,appleEventQuitUPP, 0, false);
  246.  
  247.             if (errCode != noErr) 
  248.             {
  249.                 sprintf(gErrorMessage,"InstallOrRemoveAEHandlers: AEInstallEventHandler(kAEQuitApplication) error %d",(int) errCode);
  250.                 errCode = -1;
  251.                 goto EXITPOINT;
  252.             }
  253.         }
  254.         
  255.         
  256.         
  257.         if (appleEventPrintUPP == nil)
  258.         {
  259.             doAEObjectInit = true;
  260.             
  261.             
  262.             appleEventPrintUPP = NewAEEventHandlerProc(AEPrintHandler);
  263.  
  264.             if (appleEventOpenDocUPP == nil)
  265.             {
  266.                 sprintf(gErrorMessage,"InstallOrRemoveAEHandlers: NewAEEventHandlerProc(AEPrintHandler) returned nil");
  267.                 errCode = -1;
  268.                 goto EXITPOINT;
  269.             }
  270.         
  271.             errCode = AEInstallEventHandler(kCoreEventClass,kAEPrintDocuments,appleEventPrintUPP, 0, false);
  272.  
  273.             if (errCode != noErr) 
  274.             {
  275.                 sprintf(gErrorMessage,"InstallOrRemoveAEHandlers: AEInstallEventHandler(kAEPrintDocuments) error %d",(int) errCode);
  276.                 errCode = -1;
  277.                 goto EXITPOINT;
  278.             }
  279.         }
  280.         
  281.         
  282.         if (doAEObjectInit == true)
  283.         {
  284.             errCode = AEObjectInit();
  285.             
  286.             if (errCode != noErr)
  287.             {
  288.                 sprintf(gErrorMessage,"InstallOrRemoveAEHandlers: AEObjectInit() error %d",(int) errCode);
  289.                 errCode = -1;
  290.                 goto EXITPOINT;
  291.             }
  292.         }
  293.         
  294.         
  295.         errCode = noErr;
  296.     }
  297.     
  298.     
  299.     if (removeAEHandlers == true)
  300.     {
  301.         if (appleEventOpenUPP != nil && AERemoveEventHandler(kCoreEventClass,kAEOpenApplication,appleEventOpenUPP, false) != noErr) 
  302.         {
  303.             sprintf(gErrorMessage,"InstallOrRemoveAEHandlers: AERemoveEventHandler(kAEOpenApplication) error %d",(int) errCode);
  304.             errCode = -1;
  305.         }
  306.             
  307.  
  308.         if (appleEventOpenDocUPP != nil && AERemoveEventHandler(kCoreEventClass,kAEOpenDocuments,appleEventOpenDocUPP, false) != noErr) 
  309.         {
  310.             sprintf(gErrorMessage,"InstallOrRemoveAEHandlers: AERemoveEventHandler(kAEOpenDocuments) error %d",(int) errCode);
  311.             errCode = -1;
  312.         }
  313.         
  314.  
  315.         if (appleEventQuitUPP != nil && AERemoveEventHandler(kCoreEventClass,kAEQuitApplication,appleEventQuitUPP, false) != noErr) 
  316.         {
  317.             sprintf(gErrorMessage,"InstallOrRemoveAEHandlers: AERemoveEventHandler(kAEQuitApplication) error %d",(int) errCode);
  318.             errCode = -1;
  319.         }
  320.         
  321.  
  322.         if (appleEventPrintUPP != nil && AERemoveEventHandler(kCoreEventClass,kAEPrintDocuments,appleEventPrintUPP, false) != noErr) 
  323.         {
  324.             sprintf(gErrorMessage,"InstallOrRemoveAEHandlers: AERemoveEventHandler(kAEPrintDocuments) error %d",(int) errCode);
  325.             errCode = -1;
  326.         }
  327.         
  328.         
  329.         errCode = noErr;
  330.     }
  331.  
  332.  
  333. EXITPOINT:
  334.  
  335.     return(errCode);
  336. }
  337.  
  338.  
  339.  
  340.  
  341. //    Handle an Apple Event
  342.  
  343. static OSErr DoAEEvent(EventRecord *AERecord)
  344. {
  345. int        errCode = noErr;
  346.  
  347.  
  348.     errCode = AEProcessAppleEvent(AERecord);
  349.     
  350.     if (errCode != noErr)
  351.     {
  352.         sprintf(gErrorMessage,"DoAEEvent: AEProcessAppleEvent() error %d",(int) errCode);
  353.         errCode = -1;
  354.         goto EXITPOINT;
  355.     }
  356.  
  357.  
  358. EXITPOINT:
  359.     
  360.     return(errCode);
  361. }
  362.  
  363.  
  364.  
  365.  
  366.  
  367. static pascal OSErr AEOpenHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  368. {
  369.     return(noErr);
  370. }
  371.  
  372.  
  373.  
  374. //    This is the important one
  375.  
  376. static pascal OSErr AEOpenDocHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  377. {
  378. OSErr            errCode = noErr;
  379. AEDescList        theDesc;
  380. Boolean            gotDesc = false;
  381. FSSpec            theFSSpec;
  382. int                i;
  383. long            numFilesToOpen;
  384. AEKeyword        ignoredKeyWord;
  385. DescType        ignoredType;
  386. Size            ignoredSize;
  387. FInfo            fileInfo;
  388. DescType        ignoredActualType;
  389. AEKeyword        missedKeyword;
  390. Size            ignoredActualSize;
  391. Boolean            targetIsFolder,wasAliased;
  392. short            theFRefNum = 0;
  393. long            byteCount;
  394. Handle            tempHandle = nil;
  395. char            cFileName[256];
  396. char            cTempFileName[256];
  397. short            tempFolderVRefNum = 0;
  398. long            tempFolderDirID = 0;
  399. FSSpec            tempFSSpec;
  400. register char    *srcCharPtr,*dstCharPtr;
  401. register long    tempByteCount;
  402. DialogPtr        theDPtr = nil;
  403. short            type;
  404. Handle            theItem;
  405. Rect            theRect;
  406. char            tempString[256];
  407.  
  408.     
  409. //    Get the list of dropped files
  410.  
  411.     errCode = AEGetParamDesc(messagein, keyDirectObject, typeAEList, &theDesc);
  412.     
  413.     if (errCode != noErr) 
  414.     {
  415.         sprintf(gErrorMessage,"AEOpenDocHandler: AEGetParamDesc() error %d", (int) errCode);
  416.         errCode = -1;
  417.         goto EXITPOINT;
  418.     }
  419.     
  420.     gotDesc = true;
  421.     
  422.     
  423.     errCode = AEGetAttributePtr(messagein, keyMissedKeywordAttr, typeKeyword, &ignoredActualType, (Ptr) &missedKeyword, sizeof(missedKeyword), &ignoredActualSize);
  424.     
  425.     if (errCode == noErr)
  426.     {
  427.         sprintf(gErrorMessage,"AEOpenDocHandler: received an Apple Event containing unexpected parameters");
  428.         errCode = -1;
  429.         goto EXITPOINT;
  430.     }
  431.     
  432.     
  433.     
  434.     errCode = AECountItems(&theDesc, &numFilesToOpen);
  435.     
  436.     if (errCode != noErr)
  437.     {
  438.         sprintf(gErrorMessage,"AEOpenDocHandler: AECountItems() error %d",(int) errCode);
  439.         errCode = -1;
  440.         goto EXITPOINT;
  441.     }
  442.     
  443.     
  444. //    Process all dropped files
  445.     
  446.     for (i = 1;i <= numFilesToOpen;i++) 
  447.     {
  448.         errCode = AEGetNthPtr(&theDesc, i, typeFSS, &ignoredKeyWord, &ignoredType, (Ptr) &theFSSpec, sizeof(theFSSpec),&ignoredSize);
  449.         
  450.         if (errCode != noErr)
  451.         {
  452.             sprintf(gErrorMessage,"AEOpenDocHandler: AEGetNthPtr(%d) error %d",(int) i,(int) errCode);
  453.             errCode = -1;
  454.             goto EXITPOINT;
  455.         }
  456.         
  457.         
  458.         PtoCstr(theFSSpec.name);
  459.         strcpy(cFileName,(char *) theFSSpec.name);
  460.         CtoPstr((char *) theFSSpec.name);
  461.  
  462.     
  463.     //    Deal with dropped aliases
  464.     
  465.         errCode = ResolveAliasFile(&theFSSpec,true,&targetIsFolder,&wasAliased);
  466.         
  467.         if (errCode != noErr)
  468.         {
  469.             sprintf(gErrorMessage,"AEOpenDocHandler: ResolveAliasFile(%s) error %d",cFileName,(int) errCode);
  470.             errCode = -1;
  471.             goto EXITPOINT;
  472.         }
  473.  
  474.     
  475.     //    Make sure it was a file
  476.         
  477.         if (targetIsFolder == false)
  478.         {
  479.             PtoCstr(theFSSpec.name);
  480.             strcpy(cFileName,(char *) theFSSpec.name);
  481.             CtoPstr((char *) theFSSpec.name);
  482.  
  483.  
  484.         //    Show progress window
  485.         
  486.             if (theDPtr == nil)
  487.             {
  488.                 theDPtr = GetNewDialog(progressDLOG,nil,(WindowPtr) -1L);
  489.                 
  490.                 if (theDPtr != nil)
  491.                 {
  492.                     SetPort(theDPtr);
  493.                     
  494.                     CenterWindow(theDPtr);
  495.                     ShowWindow(theDPtr);
  496.                 }
  497.             }
  498.             
  499.             if (theDPtr != nil)
  500.             {
  501.                 sprintf(tempString,"Processing file '%s'",cFileName);
  502.                 CtoPstr(tempString);
  503.                 
  504.                 GetDialogItem(theDPtr,1,&type,&theItem,&theRect);
  505.                 
  506.                 SetDialogItemText(theItem,(unsigned char *) tempString);
  507.             }
  508.             
  509.  
  510.         //    Read in dropped file
  511.         
  512.             errCode = FSpOpenDF(&theFSSpec,fsRdPerm,&theFRefNum);
  513.             
  514.             if (errCode != noErr)
  515.             {
  516.                 sprintf(gErrorMessage,"AEOpenDocHandler: FSpOpenDF('%s') error %d",cFileName,(int) errCode);
  517.                 errCode = -1;
  518.                 goto EXITPOINT;
  519.             }
  520.  
  521.             errCode = GetEOF(theFRefNum,&byteCount);
  522.             
  523.             if (errCode != noErr)
  524.             {
  525.                 sprintf(gErrorMessage,"AEOpenDocHandler: GetEOF('%s') error %d",cFileName,(int) errCode);
  526.                 errCode = -1;
  527.                 goto EXITPOINT;
  528.             }
  529.  
  530.             
  531.             tempHandle = NewHandle(byteCount);
  532.             
  533.             if (tempHandle == nil)
  534.             {
  535.                 sprintf(gErrorMessage,"AEOpenDocHandler: NewHandle(%ld) error %d",(long) byteCount,(int) MemError());
  536.                 errCode = -1;
  537.                 goto EXITPOINT;
  538.             }
  539.     
  540.     
  541.             HLock(tempHandle);
  542.             
  543.             errCode = FSRead(theFRefNum,&byteCount,*tempHandle);
  544.             
  545.             HUnlock(tempHandle);
  546.             
  547.             if (errCode != noErr)
  548.             {
  549.                 sprintf(gErrorMessage,"AEOpenDocHandler: FSRead('%s') error %d",cFileName,(int) errCode);
  550.                 errCode = -1;
  551.                 goto EXITPOINT;
  552.             }
  553.  
  554.     
  555.             errCode = FSClose(theFRefNum);
  556.             
  557.             theFRefNum = 0;
  558.  
  559.             if (errCode != noErr)
  560.             {
  561.                 sprintf(gErrorMessage,"AEOpenDocHandler: FSClose('%s') error %d",cFileName,(int) errCode);
  562.                 errCode = -1;
  563.                 goto EXITPOINT;
  564.             }
  565.             
  566.             
  567.         //    Strip out DOS/Windoze LF's
  568.         
  569.             srcCharPtr = *tempHandle;
  570.             dstCharPtr = *tempHandle;
  571.             tempByteCount = byteCount;
  572.             
  573.             while (tempByteCount > 0)
  574.             {
  575.                 if (*srcCharPtr != kLFChar)
  576.                 {
  577.                     *dstCharPtr++ = *srcCharPtr;
  578.                 }
  579.                 
  580.                 srcCharPtr++;
  581.                 tempByteCount--;
  582.             }
  583.             
  584.             byteCount = dstCharPtr - *tempHandle;;
  585.             
  586.             
  587.             
  588.         //    Create a temporary file in the temp folder
  589.             
  590.             errCode = FindFolder(theFSSpec.vRefNum,kTemporaryFolderType,kCreateFolder,&tempFolderVRefNum,&tempFolderDirID);
  591.             
  592.             if (errCode != noErr)
  593.             {
  594.                 sprintf(gErrorMessage,"AEOpenDocHandler: FindFolder(kTemporaryFolderType) error %d",(int) errCode);
  595.                 errCode = -1;
  596.                 goto EXITPOINT;
  597.             }
  598.             
  599.             
  600.             strcpy(cTempFileName,kTempFileName);
  601.  
  602.  
  603.         //    Write out the massaged data to the temp file
  604.         
  605.             CtoPstr(cTempFileName);
  606.  
  607.             errCode = FSMakeFSSpec(tempFolderVRefNum,tempFolderDirID,(unsigned char *) cTempFileName,&tempFSSpec);
  608.  
  609.             PtoCstr((unsigned char *) cTempFileName);
  610.             
  611.             if (errCode != noErr && errCode != fnfErr)
  612.             {
  613.                 sprintf(gErrorMessage,"AEOpenDocHandler: FSMakeFSSpec(%s) error %d",cTempFileName,(int) errCode);
  614.                 errCode = -1;
  615.                 goto EXITPOINT;
  616.             }
  617.  
  618.                         
  619.             errCode = FSpOpenDF(&tempFSSpec,fsRdWrPerm,&theFRefNum);
  620.             
  621.             if (errCode == fnfErr)
  622.             {
  623.                 errCode = FSpCreate(&tempFSSpec,kMWCWCreatorType,kMWCWTEXTType,0);
  624.                 
  625.                 if (errCode != noErr)
  626.                 {
  627.                     sprintf(gErrorMessage,"AEOpenDocHandler: FSpCreate(%s) error %d",cTempFileName,(int) errCode);
  628.                     errCode = -1;
  629.                     goto EXITPOINT;
  630.                 }
  631.                 
  632.                 errCode = FSpOpenDF(&tempFSSpec,fsRdWrPerm,&theFRefNum);
  633.             }
  634.             
  635.             if (errCode != noErr)
  636.             {
  637.                 sprintf(gErrorMessage,"AEOpenDocHandler: FSpOpenDF(%s) error %d",cTempFileName,(int) errCode);
  638.                 errCode = -1;
  639.                 goto EXITPOINT;
  640.             }
  641.             
  642.             
  643.             errCode = SetEOF(theFRefNum,0L);
  644.             
  645.             if (errCode != noErr)
  646.             {
  647.                 sprintf(gErrorMessage,"AEOpenDocHandler: SetEOF(%s) error %d",cTempFileName,(int) errCode);
  648.                 errCode = -1;
  649.                 goto EXITPOINT;
  650.             }
  651.             
  652.  
  653.             errCode = SetFPos(theFRefNum,fsFromStart,0L);
  654.  
  655.             if (errCode != noErr)
  656.             {
  657.                 sprintf(gErrorMessage,"AEOpenDocHandler: SetFPos(%s) error %d",cTempFileName,(int) errCode);
  658.                 errCode = -1;
  659.                 goto EXITPOINT;
  660.             }
  661.             
  662.             
  663.             HLock(tempHandle);
  664.             
  665.             errCode = FSWrite(theFRefNum,&byteCount,*tempHandle);
  666.             
  667.             HUnlock(tempHandle);
  668.             
  669.             if (errCode != noErr)
  670.             {
  671.                 sprintf(gErrorMessage,"AEOpenDocHandler: FSWrite(%s) error %d",cTempFileName,(int) errCode);
  672.                 errCode = -1;
  673.                 goto EXITPOINT;
  674.             }
  675.             
  676.  
  677.             errCode = FSClose(theFRefNum);
  678.             
  679.             theFRefNum = 0;
  680.             
  681.             if (errCode != noErr)
  682.             {
  683.                 sprintf(gErrorMessage,"AEOpenDocHandler: FSClose(%s) error %d",cTempFileName,(int) errCode);
  684.                 errCode = -1;
  685.                 goto EXITPOINT;
  686.             }
  687.             
  688.             
  689.         //    Swap data forks of files
  690.         
  691.             errCode = FSpExchangeFiles(&tempFSSpec,&theFSSpec);
  692.             
  693.             if (errCode != noErr)
  694.             {
  695.                 sprintf(gErrorMessage,"AEOpenDocHandler: FSpExchangeFiles() error %d",(int) errCode);
  696.                 errCode = -1;
  697.                 goto EXITPOINT;
  698.             }
  699.     
  700.     
  701.             if (tempHandle != nil)
  702.             {
  703.                 DisposeHandle(tempHandle);
  704.                 
  705.                 tempHandle = nil;
  706.             }
  707.  
  708.  
  709.  
  710.             PtoCstr(theFSSpec.name);
  711.             strcpy(cFileName,(char *) theFSSpec.name);
  712.             CtoPstr((char *) theFSSpec.name);
  713.             
  714.         
  715.         //    Set the type/creator of the file
  716.         
  717.             errCode = FSpGetFInfo(&theFSSpec,&fileInfo);
  718.  
  719.             if (errCode != noErr)
  720.             {
  721.                 sprintf(gErrorMessage,"AEOpenDocHandler: FSpGetFInfo(%s) error %d",cFileName,(int) errCode);
  722.                 errCode = -1;
  723.                 goto EXITPOINT;
  724.             }
  725.             
  726.             
  727.             fileInfo.fdType = kMWCWTEXTType;
  728.             fileInfo.fdCreator = kMWCWCreatorType;
  729.  
  730.             errCode = FSpSetFInfo(&theFSSpec,&fileInfo);
  731.  
  732.             if (errCode != noErr)
  733.             {
  734.                 sprintf(gErrorMessage,"AEOpenDocHandler: FSpSetFInfo(%s) error %d",cFileName,(int) errCode);
  735.                 errCode = -1;
  736.                 goto EXITPOINT;
  737.             }
  738.             
  739.             
  740.         //    Flush the volume to write the changes to disk
  741.         
  742.             errCode = FlushVol("\p",theFSSpec.vRefNum);            
  743.             
  744.             if (errCode != noErr)
  745.             {
  746.                 sprintf(gErrorMessage,"AEOpenDocHandler: FlushVol() error %d",(int) errCode);
  747.                 errCode = -1;
  748.                 goto EXITPOINT;
  749.             }
  750.         }
  751.     }
  752.  
  753.  
  754.     errCode = noErr;
  755.     
  756.  
  757. EXITPOINT:
  758.  
  759.     if (theDPtr != nil)
  760.     {
  761.         DisposeDialog(theDPtr);
  762.         
  763.         theDPtr = nil;
  764.     }
  765.         
  766.     if (tempHandle != nil)
  767.     {
  768.         DisposeHandle(tempHandle);
  769.         
  770.         tempHandle = nil;
  771.     }
  772.     
  773.     if (theFRefNum != 0)
  774.     {
  775.         FSClose(theFRefNum);
  776.     
  777.         theFRefNum = 0;
  778.     }
  779.  
  780.     
  781.     
  782.     if (gotDesc != false)
  783.     {
  784.         errCode = AEDisposeDesc(&theDesc);
  785.         
  786.         if (errCode != noErr)
  787.         {
  788.             sprintf(gErrorMessage,"AEOpenDocHandler: AEDisposeDesc() error %d",(int) errCode);
  789.             errCode = -1;
  790.         }
  791.         
  792.         gotDesc = false;
  793.     }
  794.     
  795.  
  796.     if (errCode != noErr)
  797.     {
  798.         errCode = errAEEventNotHandled;
  799.     }
  800.     
  801.     return(errCode);
  802. }
  803.  
  804.  
  805.  
  806.  
  807.  
  808. static pascal OSErr AEPrintHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  809. {
  810.     return(errAEEventNotHandled);
  811. }
  812.  
  813.  
  814.  
  815. static pascal OSErr AEQuitHandler( AppleEvent *messagein, AppleEvent *reply, long refIn )
  816. {
  817.     gAlive = false;
  818.     
  819.     return(noErr);
  820. }
  821.  
  822.  
  823.  
  824.  
  825.  
  826.  
  827.  
  828. //    A useful kludge for handling keystrokes in dialogs
  829.  
  830. static Boolean ProcessDialogCmdKey(DialogPtr theDPtr,EventRecord *theEvent,short *itemHit)
  831. {
  832. char        ch,tempString[256];
  833. int            i,j,length,numItems;
  834. Handle        itemHandle;
  835. Rect        tempRect;
  836. long        theTicks;
  837. short        itemType;
  838. Boolean        theResult;
  839.  
  840.  
  841.     theResult = false;
  842.     
  843.  
  844.     if ((*theEvent).what == keyDown || (*theEvent).what == autoKey)
  845.     {
  846.         ch = (*theEvent).message & charCodeMask;
  847.         
  848.         if (ch >= 'a' && ch <= 'z')
  849.         {
  850.             ch = 'A' + ch - 'a';
  851.         }
  852.         
  853.         
  854.         if ((*((DialogPeek) theDPtr)).aDefItem > 0 && (ch == '\r' || ch == '\n' || ch == kEnterChar))
  855.         {
  856.             GetDialogItem(theDPtr,(*((DialogPeek) theDPtr)).aDefItem,&itemType,&itemHandle,&tempRect);
  857.             
  858.             HiliteControl((ControlHandle) itemHandle,kControlButtonPart);
  859.             
  860.             theTicks = TickCount();
  861.             
  862.             while (TickCount() < theTicks + 15)
  863.             {
  864.                 
  865.             }
  866.             
  867.             HiliteControl((ControlHandle) itemHandle,0);
  868.             
  869.             *itemHit = (*((DialogPeek) theDPtr)).aDefItem;
  870.             
  871.             theResult = true;
  872.             
  873.             goto EXITPOINT;
  874.         }
  875.         
  876.  
  877.         if (((*theEvent).modifiers & cmdKey) && (*((DialogPeek) theDPtr)).editField != -1 && (*((DialogPeek) theDPtr)).textH != nil)
  878.         {
  879.             switch (ch)
  880.             {
  881.                 case 'C':
  882.                     DialogCopy(theDPtr);
  883.                     *itemHit = -1;
  884.                     theResult = true;
  885.                     goto EXITPOINT;
  886.                     break;
  887.                 
  888.                 case 'V':
  889.                     DialogPaste(theDPtr);
  890.                     *itemHit = -1;
  891.                     theResult = true;
  892.                     goto EXITPOINT;
  893.                     break;
  894.                 
  895.                 case 'X':
  896.                     DialogCut(theDPtr);
  897.                     *itemHit = -1;
  898.                     theResult = true;
  899.                     goto EXITPOINT;
  900.                     break;
  901.                 
  902.                 case 'A':
  903.                     SelectDialogItemText(theDPtr, (*((DialogPeek) theDPtr)).editField + 1, 0, 256);
  904.                     *itemHit = -1;
  905.                     theResult = true;
  906.                     goto EXITPOINT;
  907.                     break;
  908.             }
  909.         }
  910.         
  911.  
  912.         if (((*theEvent).modifiers & cmdKey) || ((*((DialogPeek) theDPtr)).editField == -1) || ((*((DialogPeek) theDPtr)).textH == nil) || ch == kEscapeChar)
  913.         {
  914.             numItems = CountDITL(theDPtr);
  915.             
  916.             if (numItems >= 1)
  917.             {
  918.                 for (i=1;i<=numItems;i++)
  919.                 {
  920.                     GetDialogItem(theDPtr,i,&itemType,&itemHandle,&tempRect);
  921.                     
  922.                     if (itemType == ctrlItem + btnCtrl && itemHandle != nil)
  923.                     {
  924.                         GetControlTitle((ControlHandle) itemHandle,(unsigned char *) tempString);
  925.                         
  926.                         if (ch == kEscapeChar || ch == '.')
  927.                         {
  928.                             PtoCstr((unsigned char *) tempString);
  929.                             
  930.                             if (strcmp(tempString,"Cancel") == EQSTR)
  931.                             {
  932.                                 GetDialogItem(theDPtr,i,&itemType,&itemHandle,&tempRect);
  933.                                 
  934.                                 HiliteControl((ControlHandle) itemHandle,kControlButtonPart);
  935.                                 
  936.                                 theTicks = TickCount();
  937.                                 
  938.                                 while (TickCount() < theTicks + 15)
  939.                                 {
  940.                                 
  941.                                 }
  942.                                 
  943.                                 HiliteControl((ControlHandle) itemHandle,0);
  944.                                 
  945.                                 *itemHit = i;
  946.                                 
  947.                                 theResult = true;
  948.                                 goto EXITPOINT;
  949.                             }
  950.                         }
  951.                         
  952.                         else
  953.                         {
  954.                             length = tempString[0];
  955.                             
  956.                             for (j=1;j<=length;j++)
  957.                             {
  958.                                 if (tempString[j] >= 'A' && tempString[j] <= 'Z')
  959.                                 {
  960.                                     if (tempString[j] == ch)
  961.                                     {
  962.                                         GetDialogItem(theDPtr,i,&itemType,&itemHandle,&tempRect);
  963.                                         
  964.                                         HiliteControl((ControlHandle) itemHandle,kControlButtonPart);
  965.                                         
  966.                                         theTicks = TickCount();
  967.                                         
  968.                                         while (TickCount() < theTicks + 15)
  969.                                         {
  970.                                         
  971.                                         }
  972.                                         
  973.                                         HiliteControl((ControlHandle) itemHandle,0);
  974.                                         
  975.                                         *itemHit = i;
  976.                                         
  977.                                         theResult = true;
  978.                                         goto EXITPOINT;
  979.                                     }
  980.                                     
  981.                                     else
  982.                                     {
  983.                                         j = length + 1;
  984.                                     }
  985.                                 }
  986.                             }
  987.                         }
  988.                     }
  989.                 }
  990.                 
  991.                 if (ch != 'X' && ch != 'C' && ch != 'V' && ch != 'A')
  992.                 {
  993.                     SysBeep(1);
  994.                 }
  995.             }
  996.         }
  997.     }
  998.  
  999.  
  1000. EXITPOINT:
  1001.  
  1002.     return(theResult);
  1003. }
  1004.  
  1005.  
  1006.  
  1007. pascal Boolean MyDialogFilter(DialogPtr theDPtr,EventRecord *theEvent,short *itemHit)
  1008. {
  1009. Boolean        theResult;
  1010.  
  1011.  
  1012.     theResult = ProcessDialogCmdKey(theDPtr,theEvent,itemHit);
  1013.     
  1014.     return(theResult);
  1015. }
  1016.  
  1017.  
  1018.  
  1019. //    Also handy....
  1020.  
  1021. static void CenterWindow(WindowPtr wPtr)
  1022. {
  1023. int        screenWidth,screenHeight,windowWidth,windowHeight,left,top;
  1024.  
  1025.  
  1026.     if (wPtr == nil)
  1027.     {
  1028.         return;
  1029.     }
  1030.     
  1031.     screenWidth = qd.screenBits.bounds.right - qd.screenBits.bounds.left;
  1032.     screenHeight = qd.screenBits.bounds.bottom - qd.screenBits.bounds.top - 20;
  1033.     
  1034.     windowWidth = wPtr->portRect.right - wPtr->portRect.left;
  1035.     windowHeight = wPtr->portRect.bottom - wPtr->portRect.top + 20;
  1036.     
  1037.     
  1038.     left = qd.screenBits.bounds.left + (screenWidth - windowWidth)/2;
  1039.     
  1040.     top = qd.screenBits.bounds.top + 20 + (screenHeight - windowHeight)/2;
  1041.     
  1042.     if (left < 0)
  1043.         left = 0;
  1044.     
  1045.     if (top < 40)
  1046.         top = 40;
  1047.     
  1048.     MoveWindow(wPtr,left,top,false);
  1049. }
  1050.  
  1051.  
  1052.  
  1053. //    Stupid MacOS didn't use to hilite the default button
  1054.  
  1055. static pascal void HiliteDefaultButton(DialogPtr theDPtr,short whichItem)
  1056. {
  1057. short        type;
  1058. Handle        theItem;
  1059. Rect        theRect;
  1060. PenState    thePenState;
  1061. GrafPtr        oldPort;
  1062.  
  1063.  
  1064.     if (theDPtr != nil && (*((DialogPeek) theDPtr)).aDefItem > 0)
  1065.     {
  1066.         GetPort(&oldPort);
  1067.         SetPort(theDPtr);
  1068.         
  1069.         GetPenState(&thePenState);
  1070.         
  1071.         GetDialogItem(theDPtr, (*((DialogPeek) theDPtr)).aDefItem, &type, &theItem, &theRect);
  1072.         PenNormal();
  1073.         PenSize(3,3);
  1074.         InsetRect(&theRect,-4,-4);
  1075.         FrameRoundRect(&theRect,16,16);
  1076.         PenSize(1,1);
  1077.         
  1078.         SetPenState(&thePenState);
  1079.         SetPort(oldPort);
  1080.     }
  1081. }
  1082.  
  1083.  
  1084.  
  1085. //    Show an alert with a message
  1086.  
  1087. static void ErrorAlert(char *theErrorMessage)
  1088. {
  1089. GrafPtr            oldPort;
  1090. DialogPtr        theDPtr;
  1091. short            itemHit;
  1092. short            type;
  1093. Handle            theItem;
  1094. Rect            theRect;
  1095.  
  1096.  
  1097.     GetPort(&oldPort);
  1098.     
  1099.     InitCursor();
  1100.     
  1101.     SysBeep(1);
  1102.  
  1103.  
  1104.     theDPtr = GetNewDialog(errorDLOG, nil,(WindowPtr) -1L);
  1105.     
  1106.     if (theDPtr != nil)
  1107.     {
  1108.         SetPort(theDPtr);
  1109.         
  1110.         CenterWindow(theDPtr);
  1111.         ShowWindow(theDPtr);
  1112.         
  1113.         (*((DialogPeek) theDPtr)).aDefItem = 1;
  1114.         
  1115.         GetDialogItem(theDPtr, 3, &type, &theItem, &theRect);
  1116.         SetDialogItem(theDPtr, 3, type,(Handle) gMyHiliteDefaultButtonProc, &theRect);
  1117.         
  1118.         GetDialogItem(theDPtr, 2, &type, &theItem, &theRect);
  1119.         CtoPstr(theErrorMessage);
  1120.         SetDialogItemText(theItem,(unsigned char *) theErrorMessage);
  1121.         PtoCstr((unsigned char *) theErrorMessage);
  1122.         
  1123.         TEFromScrap();
  1124.         
  1125.         do 
  1126.         {
  1127.             ModalDialog(gMyModalFilterProc,&itemHit);
  1128.             
  1129.         } while (itemHit!=1);
  1130.         
  1131.         ZeroScrap();
  1132.         
  1133.         TEToScrap();
  1134.         
  1135.         DisposeDialog(theDPtr);
  1136.         SetPort(oldPort);
  1137.     }
  1138. }
  1139.