home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / µSim 1.1 / FabLibsƒ / UtilsCommon.c < prev    next >
Encoding:
Text File  |  1997-05-25  |  46.9 KB  |  1,833 lines  |  [TEXT/CWIE]
  1. /*
  2. Copyright © 1993-1997 by Fabrizio Oddone
  3. ••• ••• ••• ••• ••• ••• ••• ••• ••• •••
  4. This source code is distributed as freeware: you can copy, exchange, modify this
  5. code as you wish. You may include this code in any kind of application: freeware,
  6. shareware, or commercial, provided that full credits are given.
  7. You may not sell or distribute this code for profit.
  8. */
  9.  
  10. //#pragma load "MacDump"
  11.  
  12. #ifndef __MOREFILESEXTRAS__
  13. #include "MoreFilesExtras.h"
  14. #endif
  15.  
  16. #include    <Limits.h>
  17. #include    "FabLibResIDs.h"
  18. #include    "Independents.h"
  19. #include    "MovableModal.h"
  20.  
  21.  
  22. #define    offer(x, qty)    ((UInt32)(x * FracSqrt(qty)) >> 15)
  23.  
  24. static OSErr PutAliasIntoAEDirectObj(AppleEvent * const myAEvent, Handle theAlias);
  25. static void ZoomRectToRect(const Rect * const startingRect, const Rect * const endingRect, short numofDivs);
  26. static void ZoomRectToRectAutoGrafPort(const Rect * const startingRect, const Rect * const endingRect, short numofDivs);
  27. static void CommonCopyToClip(short id);
  28. static long RegisterStdConfigInfo(Handle regText, long curOffset, StringPtr tempS);
  29.  
  30. #if !(defined(powerc) || defined (__powerc)) || defined(FabSystem7orlater)
  31.  
  32. #if    !defined(FabNoSegmentDirectives)
  33. #pragma segment Main
  34. #endif
  35.  
  36. static AEEventHandlerUPP    gmyOAPP_UPP, gmyODOC_UPP, gmyPDOC_UPP, gmyQUIT_UPP;
  37.  
  38. #if defined(powerc) || defined (__powerc)
  39.  
  40. pascal StringPtr     PLstrcpy(StringPtr str1, ConstStr255Param str2)
  41. {
  42. BlockMoveData(str2, str1, StrLength(str2) + 1);
  43. return str1;
  44. }
  45.  
  46. pascal StringPtr     PLstrncpy(StringPtr str1, ConstStr255Param str2, short num)
  47. {
  48. BlockMoveData(str2, str1, 1 + MIN(StrLength(str2), num));
  49. return str1;
  50. }
  51.  
  52. pascal StringPtr    PLstrcat(StringPtr str1, ConstStr255Param str2)
  53. {
  54. BlockMoveData(str2 + 1, str1 + StrLength(str1) + 1, StrLength(str2));
  55. StrLength(str1) += StrLength(str2);
  56. return str1;
  57. }
  58.  
  59. pascal StringPtr    PLstrncat(StringPtr str1, ConstStr255Param str2, short num)
  60. {
  61. BlockMoveData(str2 + 1, str1 + StrLength(str1) + 1, MIN(num, StrLength(str2)));
  62. StrLength(str1) += StrLength(str2);
  63. return str1;
  64. }
  65.  
  66. void MyZeroBuffer(long *p, long s)
  67. {
  68. for ( ; s-- >= 0; *p++ = 0L) ;
  69. }
  70.  
  71. void MyFillBuffer(long *p, long s, long filler)
  72. {
  73. for ( ; s-- >= 0; *p++ = filler) ;
  74. }
  75.  
  76. long mySwap(long s)
  77. {
  78. long    t;
  79.  
  80. t = s >> 16;
  81. *(short *)&t = (short) s;
  82. return t;
  83. }
  84.  
  85. #endif
  86.  
  87.  
  88. void ZoomingRects(ZoomFactorRec * const zfr, const Rect * const firstRect, const Rect * const lastRect, ZoomAcceleration acc)
  89. {
  90. UInt32    elapsed;
  91. short    *steps;
  92.  
  93. elapsed = TickCount();
  94.  
  95. if (HasDragManager()) {
  96.     (void) ZoomRects(firstRect, lastRect, zfr->DragMFactor, acc);
  97.     steps = &zfr->DragMFactor;
  98.     }
  99. else {
  100.     ZoomRectToRectAutoGrafPort(firstRect, lastRect, zfr->myFactor);
  101.     steps = &zfr->myFactor;
  102.     }
  103.  
  104. elapsed = TickCount() - elapsed;
  105. if (elapsed < 6UL)
  106.     *steps += 1;
  107. else if (elapsed > 11UL)
  108.     *steps -= 1;
  109. }
  110.  
  111. /* AddSTRRes2Doc: adds the standard 'STR ' resource to a document */
  112.  
  113. OSErr AddSTRRes2Doc(const FSSpecPtr theDoc, OSType myFcrea, OSType myFtype, short STRid, ScriptCode lScript)
  114. {
  115. register Handle    existHandle;
  116. register Handle    msgString;
  117. register short    fRefn;
  118. register OSErr    err;
  119. Boolean    attemptRemoveResource = false;
  120.  
  121. DetachResource(msgString = (Handle)GetString(STRid));
  122. FSpCreateResFileCompat(theDoc, myFcrea, myFtype, lScript);
  123. if ((err = ResError()) == dupFNErr)
  124.     attemptRemoveResource = true;
  125.  
  126. if (err == noErr || err == dupFNErr)
  127.     if ((fRefn = FSpOpenResFileCompat(theDoc, fsRdWrPerm)) == -1)
  128.         err = ResError();
  129.     else {
  130.         if (attemptRemoveResource) {
  131.             SetResLoad(false);
  132.             existHandle = Get1Resource('STR ', STRid);
  133.             SetResLoad(true);
  134.             if (existHandle) {
  135.                 RemoveResource(existHandle);
  136.                 DisposeHandle(existHandle);
  137.                 }
  138.             }
  139.         AddResource(msgString, 'STR ', STRid, "\p");
  140.         if ((err = ResError()) == noErr) {
  141.             SetResAttrs(msgString, GetResAttrs(msgString) | resPurgeable);
  142.             err = ResError();
  143.             }
  144.         else
  145.             DisposeHandle(msgString);
  146.         CloseResFile(fRefn);
  147.         }
  148. return err;
  149. }
  150.  
  151. /* AddSTRHand2Doc: adds the standard 'STR ' resource to a document */
  152.  
  153. OSErr AddSTRHand2Doc(const FSSpecPtr theDoc, OSType myFcrea, OSType myFtype, StringHandle msgString, ScriptCode lScript)
  154. {
  155. register Handle    existHandle;
  156. register short    fRefn;
  157. register OSErr    err;
  158. Boolean    attemptRemoveResource = false;
  159.  
  160. FSpCreateResFileCompat(theDoc, myFcrea, myFtype, lScript);
  161. if ((err = ResError()) == dupFNErr)
  162.     attemptRemoveResource = true;
  163.  
  164. if (err == noErr || err == dupFNErr)
  165.     if ((fRefn = FSpOpenResFileCompat(theDoc, fsRdWrPerm)) == -1)
  166.         err = ResError();
  167.     else {
  168.         if (attemptRemoveResource) {
  169.             SetResLoad(false);
  170.             existHandle = Get1Resource('STR ', kSTR_ApplicationName);
  171.             SetResLoad(true);
  172.             if (existHandle) {
  173.                 RemoveResource(existHandle);
  174.                 DisposeHandle(existHandle);
  175.                 }
  176.             }
  177.         AddResource((Handle)msgString, 'STR ', kSTR_ApplicationName, "\p");
  178.         if ((err = ResError()) == noErr) {
  179.             SetResAttrs((Handle)msgString, GetResAttrs((Handle)msgString) | resPurgeable);
  180.             err = ResError();
  181.             }
  182.         else
  183.             DisposeHandle((Handle)msgString);
  184.         CloseResFile(fRefn);
  185.         }
  186. return err;
  187. }
  188.  
  189. OSErr AddRes2Doc(const FSSpecPtr theDoc, Handle thisHandle, ResType rType, short rID)
  190. {
  191. register Handle    existHandle;
  192. register short    fRefn;
  193. register OSErr    err;
  194.  
  195. if ((fRefn = FSpOpenResFileCompat(theDoc, fsRdWrPerm)) == -1)
  196.     err = ResError();
  197. else {
  198. //    if (noErr == (err = HandToHand(&thisHandle)))
  199.     SetResLoad(false);
  200.     existHandle = Get1Resource(rType, rID);
  201.     SetResLoad(true);
  202.     if (existHandle) {
  203.         RemoveResource(existHandle);
  204.         DisposeHandle(existHandle);
  205.         }
  206.     AddResource(thisHandle, rType, rID, "\p");
  207.     if ((err = ResError()) == noErr) {
  208.         SetResAttrs(thisHandle, GetResAttrs(thisHandle) | resPurgeable);
  209.         err = ResError();
  210.         }
  211.     CloseResFile(fRefn);
  212.     }
  213. return err;
  214. }
  215.  
  216. OSErr AddRes2DocOpen(Handle thisHandle, ResType rType, short rID)
  217. {
  218. Handle    existHandle;
  219. //register short    fRefn;
  220. OSErr    err;
  221.  
  222. SetResLoad(false);
  223. existHandle = Get1Resource(rType, rID);
  224. SetResLoad(true);
  225. if (existHandle) {
  226.     RemoveResource(existHandle);
  227.     DisposeHandle(existHandle);
  228.     }
  229. AddResource(thisHandle, rType, rID, "\p");
  230. if ((err = ResError()) == noErr) {
  231.     SetResAttrs(thisHandle, GetResAttrs(thisHandle) | resPurgeable);
  232.     err = ResError();
  233.     }
  234.  
  235. return err;
  236. }
  237.  
  238. /* SendmyAE: we send an Apple Event with the specified ID to ourselves */
  239.  
  240. void SendmyAE(AEEventClass myclass, AEEventID myAEvtID, AEIdleProcPtr IdleFunct, AESendMode theMode)
  241. {
  242. AEIdleUPP    IdleFunctUPP = NewAEIdleProc(IdleFunct);
  243. AppleEvent    myAEvent;
  244. AppleEvent    myAEReply;
  245. AEAddressDesc    targetAddress;
  246. ProcessSerialNumber myPSN = { 0, kCurrentProcess };
  247. register OSErr    err;
  248.  
  249. if ((err = AECreateDesc(typeProcessSerialNumber, (Ptr)&myPSN, sizeof(ProcessSerialNumber),
  250.     &targetAddress)) == noErr) {
  251.     if ((err = AECreateAppleEvent(myclass, myAEvtID, &targetAddress,
  252.         kAutoGenerateReturnID, kAnyTransactionID, &myAEvent)) == noErr) {
  253.         err = AESend(&myAEvent, &myAEReply, theMode,
  254.             kAENormalPriority, kNoTimeOut, IdleFunctUPP, 0L);
  255.         (void)AEDisposeDesc(&myAEvent);
  256.         }
  257.     (void)AEDisposeDesc(&targetAddress);
  258.     }
  259. if (IdleFunctUPP)
  260.     DisposeRoutineDescriptor(IdleFunctUPP);
  261. }
  262.  
  263. /* SendmyAEPShort: we send an Apple Event with the specified ID to ourselves */
  264.  
  265. void SendmyAEPShort(AEEventClass myclass, AEEventID myAEvtID, AEIdleProcPtr IdleFunct, AESendMode theMode, short theAlert)
  266. {
  267. AEIdleUPP    IdleFunctUPP = NewAEIdleProc(IdleFunct);
  268. AppleEvent    myAEvent;
  269. AppleEvent    myAEReply;
  270. AEAddressDesc    targetAddress;
  271. ProcessSerialNumber myPSN = { 0, kCurrentProcess };
  272. register OSErr    err;
  273.  
  274. if ((err = AECreateDesc(typeProcessSerialNumber, (Ptr)&myPSN, sizeof(ProcessSerialNumber),
  275.     &targetAddress)) == noErr) {
  276.     if ((err = AECreateAppleEvent(myclass, myAEvtID, &targetAddress,
  277.         kAutoGenerateReturnID, kAnyTransactionID, &myAEvent)) == noErr) {
  278.  
  279.         if ((err = AEPutParamPtr(&myAEvent, keyDirectObject, typeShortInteger, (Ptr)&theAlert, sizeof(theAlert))) == noErr)
  280.             err = AESend(&myAEvent, &myAEReply, theMode,
  281.                 kAENormalPriority, kNoTimeOut, IdleFunctUPP, 0L);
  282.         (void)AEDisposeDesc(&myAEvent);
  283.         }
  284.     (void)AEDisposeDesc(&targetAddress);
  285.     }
  286. if (IdleFunctUPP)
  287.     DisposeRoutineDescriptor(IdleFunctUPP);
  288. }
  289.  
  290. /* SendRevealToFinder: we tell the Finder to reveal the item */
  291.  
  292. OSErr SendRevealToFinder(Handle fld, AEIdleProcPtr IdleFunct,
  293.                         void (*failProc)(void))
  294. {
  295. FSSpec    myFolderFS;
  296. AppleEvent    myAEvent;
  297. AppleEvent    myAEReply;
  298. AEIdleUPP    IdleFunctUPP = NewAEIdleProc(IdleFunct);
  299. AEAddressDesc    targetAddress;
  300. AEDescList    fileDesc;
  301. OSType    FinderCreator = 'MACS';
  302. AliasHandle    parentFolder = nil;
  303. register OSErr    err;
  304. Boolean    wasChanged;
  305.  
  306. if ((err = AECreateDesc(typeApplSignature, (Ptr)&FinderCreator, sizeof(OSType),
  307.     &targetAddress)) == noErr) {
  308.     if ((err = AECreateAppleEvent(kAEFinderEvents, kAERevealSelection, &targetAddress,
  309.         kAutoGenerateReturnID, kAnyTransactionID, &myAEvent)) == noErr) {
  310.         err = ResolveAlias(nil, (AliasHandle)fld, &myFolderFS, &wasChanged);
  311.         if (err == noErr) {
  312.             if (myFolderFS.parID == fsRtParID)
  313.                 myFolderFS.parID = fsRtDirID;
  314.             err = FSMakeFSSpecCompat(myFolderFS.vRefNum, /*myFolderFS.parID == fsRtParID ? fsRtDirID : */myFolderFS.parID, nil, &myFolderFS);
  315.             if (err == noErr) {
  316.                 err = NewAlias(nil, &myFolderFS, &parentFolder);
  317.                 if (err == noErr)
  318.                     err = PutAliasIntoAEDirectObj(&myAEvent, (Handle)parentFolder);
  319.                 }
  320.             if (err == noErr) {
  321.                 err = AECreateList(nil, 0L, false, &fileDesc);
  322.                 if (err == noErr) {
  323.                     err = AEPutPtr(&fileDesc, 1, typeAlias, *fld, InlineGetHandleSize(fld));
  324.                     if (err == noErr) {
  325.                         err = AEPutParamDesc(&myAEvent, keySelection, &fileDesc);
  326.                         if (err == noErr)
  327.                             err = AESend(&myAEvent, &myAEReply, kAENoReply | kAENeverInteract,
  328.                                 kAENormalPriority, kNoTimeOut, IdleFunctUPP, nil);
  329.                         }
  330.                     (void)AEDisposeDesc(&fileDesc);
  331.                     }
  332.                 }
  333.             }
  334.         else {
  335.             if (failProc)
  336.                 failProc();
  337.             }
  338.         (void)AEDisposeDesc(&myAEvent);
  339.         }
  340.     (void)AEDisposeDesc(&targetAddress);
  341.     }
  342. if (IdleFunctUPP)
  343.     DisposeRoutineDescriptor(IdleFunctUPP);
  344. return err;
  345. }
  346.  
  347. static OSErr PutAliasIntoAEDirectObj(AppleEvent * const myAEvent, Handle theAlias)
  348. {
  349. register OSErr    err;
  350. register SignedByte    state;
  351.  
  352. state = WantThisHandleSafe(theAlias);
  353. err = AEPutParamPtr(myAEvent, keyDirectObject, typeAlias, *theAlias, InlineGetHandleSize(theAlias));
  354. HSetState(theAlias, state);
  355. return err;
  356. }
  357.  
  358.  
  359. /* ZoomRectToRect: draws zooming gray rectangles from startingRect to endingRect
  360. in the current port; numofDivs is the density of rectangles in the interval */
  361.  
  362. void ZoomRectToRect(const Rect * const startingRect, const Rect * const endingRect, short numofDivs)
  363. {
  364. PenState    curPen;
  365. Rect    trailingRect = { 0, 0, 0, 0 };
  366. Rect    tempRect;
  367. Handle    rectStorH;
  368. short    mtop, mleft, mbottom, mright;
  369. register long    ttopleft, tbotright;
  370. register short *spntr;
  371. register long *lpntr;
  372. register int    i, j, tsh;
  373.  
  374. if (numofDivs < (CHAR_BIT * sizeof(short))) {
  375.     if (rectStorH = NewHandleGeneral(numofDivs * sizeof(Rect))) {
  376.         GetPenState(&curPen);
  377.         PenPat(&qd.gray);
  378.         PenMode(patXor);
  379.         mtop = endingRect->top - startingRect->top;
  380.         mleft = endingRect->left - startingRect->left;
  381.         mbottom = endingRect->bottom - startingRect->bottom;
  382.         mright = endingRect->right - startingRect->right;
  383.         spntr = (short *)*rectStorH;
  384.         for (i = 1; i <= numofDivs; i++) {
  385.             *spntr++ = mtop >>= 1;
  386.             *spntr++ = mleft >>= 1;
  387.             *spntr++ = mbottom >>= 1;
  388.             *spntr++ = mright >>= 1;
  389.             }
  390.         HLock(rectStorH);
  391.         for (i = 1; i < (1 << numofDivs); i++) {
  392.             ttopleft = *(long *)&topLeft(*startingRect);
  393.             tbotright = *(long *)&botRight(*startingRect);
  394.             lpntr = (long *)*rectStorH;
  395.             tsh = i << ((CHAR_BIT * sizeof(short)) - numofDivs);
  396.             for (j = 1; j <= numofDivs; j++) {
  397.                 if (tsh < 0) {
  398.                     ttopleft += *lpntr++;
  399.                     tbotright += *lpntr++;
  400.                     }
  401.                 else
  402.                     lpntr += 2;
  403.                 tsh <<= 1;
  404.                 }
  405.             
  406.             *(long *)&topLeft(tempRect) = ttopleft;
  407.             *(long *)&botRight(tempRect) = tbotright;
  408.             FrameRect(&tempRect);
  409.             FrameRect(&trailingRect);
  410.             trailingRect = tempRect;
  411.             }
  412.         FrameRect(&tempRect);
  413.         DisposeHandle(rectStorH);
  414.         SetPenState(&curPen);
  415.         }
  416.     }
  417. }
  418.  
  419. void ZoomRectToRectAutoGrafPort(const Rect * const startingRect, const Rect * const endingRect, short numofDivs)
  420. {
  421. GrafPtr        savePort;
  422. GrafPort    ZoomPort;
  423.  
  424. GetPort(&savePort);
  425. OpenPort(&ZoomPort);
  426. ZoomRectToRect(startingRect, endingRect, numofDivs);
  427. ClosePort(&ZoomPort);
  428. SetPort(savePort);
  429. }
  430.  
  431. /* NewHandleGeneral: makes a new handle in main or temporary memory, arguably
  432. in the more suitable heap zone */
  433.  
  434. Handle NewHandleGeneral(UInt32 blockSize)
  435. {
  436. register Handle    myH;
  437. OSErr    err;
  438.  
  439. if (TempFreeMem() > FreeMem()) {
  440.     if ((myH = TempNewHandle(blockSize, &err)) == nil) {
  441.         ReserveMem(blockSize);
  442.         myH = NewHandle(blockSize);
  443.         }
  444.     }
  445. else {
  446.     ReserveMem(blockSize);
  447.     if ((myH = NewHandle(blockSize)) == nil)
  448.         myH = TempNewHandle(blockSize, &err);
  449.     }
  450. return myH;
  451. }
  452.  
  453. /* Get1ResGeneral: like Get1Resource, but loads in main or temporary memory */
  454.  
  455. Handle Get1ResGeneral(ResType theType, short theID)
  456. {
  457. register Handle    emptyH, destH;
  458. register UInt32    myResSize;
  459.  
  460. SetResLoad(false);
  461. emptyH = Get1Resource(theType, theID);
  462. SetResLoad(true);
  463. destH = NewHandleGeneral(myResSize = GetResourceSizeOnDisk(emptyH));
  464. if (destH) {
  465.     HLock(destH);
  466.     ReadPartialResource(emptyH, 0L, *destH, myResSize);
  467.     HUnlock(destH);
  468.     }
  469. ReleaseResource(emptyH);
  470. return destH;
  471. }
  472.  
  473. OSType FindFinderAtEaseProcess(ProcessSerialNumber * const theProcess)
  474. {
  475. ProcessInfoRec infoRec;
  476. ProcessSerialNumber process = {0L, kNoProcess};
  477. register OSType    retVal = '????';
  478.  
  479. infoRec.processInfoLength = sizeof(ProcessInfoRec);
  480. infoRec.processName = nil;
  481. infoRec.processAppSpec = nil;
  482.  
  483. while (GetNextProcess(&process) == noErr) {
  484.     if (noErr == (GetProcessInformation(&process, &infoRec))) {
  485.         if ((infoRec.processType == (unsigned long)'FNDR') &&
  486.             ((infoRec.processSignature == 'MACS') || (infoRec.processSignature == sigAtEase))) {
  487.             
  488.             retVal = infoRec.processSignature;
  489.             *theProcess = process;
  490.             break;
  491.             }
  492.         }
  493.     }
  494. return retVal;
  495. }
  496.  
  497. OSType FindFinderProcess(void)
  498. {
  499. ProcessInfoRec infoRec;
  500. ProcessSerialNumber process = {0, kNoProcess};
  501. register OSType    retVal = '????';
  502.  
  503. infoRec.processInfoLength = sizeof(ProcessInfoRec);
  504. infoRec.processName = nil;
  505. infoRec.processAppSpec = nil;
  506.  
  507. while (GetNextProcess(&process) == noErr) {
  508.     if (noErr == (GetProcessInformation(&process, &infoRec))) {
  509.         if ((infoRec.processType == (unsigned long)'FNDR') &&
  510.             (infoRec.processSignature == 'MACS')) {
  511.             
  512.             retVal = infoRec.processSignature;
  513.             break;
  514.             }
  515.         }
  516.     }
  517. return retVal;
  518. }
  519.  
  520. /* SendShutdownToFinder: we tell the Finder (or At Ease) to Shutdown (!) */
  521.  
  522. OSErr SendShutdownToFinder(AEIdleProcPtr myIdleFunct, Boolean wantShutDown)
  523. {
  524. AEIdleUPP    myIdleFunctUPP = NewAEIdleProc(myIdleFunct);
  525. AppleEvent    myAEvent;
  526. AppleEvent    myAEReply;
  527. ProcessSerialNumber    process;
  528. AEAddressDesc    targetAddress;
  529. OSType    WantedCreator;
  530. register OSErr    err = errAEDescNotFound;
  531.  
  532. WantedCreator = FindFinderAtEaseProcess(&process);
  533. if ('????' != WantedCreator)
  534.     if ((err = AECreateDesc(typeApplSignature, (Ptr)&WantedCreator, sizeof(OSType),
  535.         &targetAddress)) == noErr) {
  536.         if ((err = AECreateAppleEvent(kAEFinderEvents, wantShutDown ? kAEShutDown : kAERestart , &targetAddress,
  537.             kAutoGenerateReturnID, kAnyTransactionID, &myAEvent)) == noErr) {
  538.             err = AESend(&myAEvent, &myAEReply, kAENoReply | kAEAlwaysInteract,
  539.                 kAENormalPriority, kNoTimeOut, myIdleFunctUPP, nil);
  540.             (void)AEDisposeDesc(&myAEvent);
  541.             if (err == noErr)
  542.                 (void)SetFrontProcess(&process);
  543.             }
  544.         (void)AEDisposeDesc(&targetAddress);
  545.         }
  546. if (myIdleFunctUPP)
  547.     DisposeRoutineDescriptor(myIdleFunctUPP);
  548. return err;
  549. }
  550.  
  551. short StopAlert_UPP(short alertID, ModalFilterProcPtr filterProc)
  552. {
  553. ModalFilterUPP    filterProcUPP = nil;
  554. register short    butHit;
  555.  
  556. if (filterProc)
  557.     filterProcUPP = NewModalFilterProc(filterProc);
  558. InitCursor();
  559. butHit = StopAlert(alertID, filterProcUPP);
  560. if (filterProcUPP)
  561.     DisposeRoutineDescriptor(filterProcUPP);
  562. return butHit;
  563. }
  564.  
  565. short StopAlert_AE(short alertID, ModalFilterProcPtr filterProc, AEIdleProcPtr IdleFunct)
  566. {
  567.  
  568. SendmyAE(kCreat, kAEAlert, IdleFunct, kAENoReply | kAEAlwaysInteract);
  569. return StopAlert_UPP(alertID, filterProc);
  570. }
  571.  
  572. short CautionAlert_UPP(short alertID, ModalFilterProcPtr filterProc)
  573. {
  574. ModalFilterUPP    filterProcUPP = nil;
  575. register short    butHit;
  576.  
  577. if (filterProc)
  578.     filterProcUPP = NewModalFilterProc(filterProc);
  579. InitCursor();
  580. butHit = CautionAlert(alertID, filterProcUPP);
  581. if (filterProcUPP)
  582.     DisposeRoutineDescriptor(filterProcUPP);
  583. return butHit;
  584. }
  585.  
  586. short CautionAlert_AE(short alertID, ModalFilterProcPtr filterProc, AEIdleProcPtr IdleFunct)
  587. {
  588.  
  589. SendmyAE(kCreat, kAEAlert, IdleFunct, kAENoReply | kAEAlwaysInteract);
  590. return CautionAlert_UPP(alertID, filterProc);
  591. }
  592.  
  593. short NoteAlert_UPP(short alertID, ModalFilterProcPtr filterProc)
  594. {
  595. ModalFilterUPP    filterProcUPP = nil;
  596. register short    butHit;
  597.  
  598. if (filterProc)
  599.     filterProcUPP = NewModalFilterProc(filterProc);
  600. InitCursor();
  601. butHit = NoteAlert(alertID, filterProcUPP);
  602. if (filterProcUPP)
  603.     DisposeRoutineDescriptor(filterProcUPP);
  604. return butHit;
  605. }
  606.  
  607. short NoteAlert_AE(short alertID, ModalFilterProcPtr filterProc, AEIdleProcPtr IdleFunct)
  608. {
  609.  
  610. SendmyAE(kCreat, kAEAlert, IdleFunct, kAENoReply | kAEAlwaysInteract);
  611. return NoteAlert_UPP(alertID, filterProc);
  612. }
  613.  
  614. short Alert_UPP(short alertID, ModalFilterProcPtr filterProc)
  615. {
  616. ModalFilterUPP    filterProcUPP = nil;
  617. register short    butHit;
  618.  
  619. if (filterProc)
  620.     filterProcUPP = NewModalFilterProc(filterProc);
  621. InitCursor();
  622. butHit = Alert(alertID, filterProcUPP);
  623. if (filterProcUPP)
  624.     DisposeRoutineDescriptor(filterProcUPP);
  625. return butHit;
  626. }
  627.  
  628. short Alert_AE(short alertID, ModalFilterProcPtr filterProc, AEIdleProcPtr IdleFunct)
  629. {
  630.  
  631. SendmyAE(kCreat, kAEAlert, IdleFunct, kAENoReply | kAEAlwaysInteract);
  632. return Alert_UPP(alertID, filterProc);
  633. }
  634.  
  635. /* my Dialog box manager */
  636.  
  637. short HandleDialog(ModalFilterProcPtr filterProc,
  638.                     dialogItemsPtr things,
  639.                     void (*initProc)(DialogPtr),
  640.                     void (*userProc)(DialogPtr, Handle, short),
  641.                     short resId)
  642. {
  643. ModalFilterUPP    filterProcUPP = NewModalFilterProc(filterProc);
  644. Rect    box;
  645. Handle    item;
  646. GrafPtr    port;
  647. register long    myRefCon;
  648. register DialogPtr    dPtr;
  649. register dialogItemsPtr    spanPtr;
  650. dialogItemsPtr    itemToBeActivated;
  651. short    type, theItemHit = memFullErr;
  652. short    theGroup, lastItemClosingDialog = cancel;
  653. register short    theType, iNum;
  654. register Boolean    editTextExists = false;
  655. Boolean    dialoging;
  656. #if !defined(FabSystem7orlater)
  657. long    Gresp;
  658. Boolean    dialogManager7Present = false;
  659. #endif
  660.  
  661. InitCursor();
  662. dPtr = GetNewDialog(resId, nil, (WindowRef)-1L);
  663. if (dPtr) {
  664.     GetPort(&port);
  665.     SetGrafPortOfDialog(dPtr);
  666.  
  667. #if !defined(FabSystem7orlater)
  668.     if (Gestalt(gestaltDITLExtAttr, &Gresp) == noErr)
  669.         if (Gresp & (1L << gestaltDITLExtPresent))
  670.             dialogManager7Present = true;
  671. #endif
  672.  
  673. #pragma mark Setup
  674.     
  675.     spanPtr = things;
  676.     while (iNum = spanPtr->itemNumber) {
  677.         myRefCon = spanPtr->refCon;
  678.         GetDialogItem(dPtr, iNum, &type, &item, &box);
  679.         theType = type & itemDisable ? type - itemDisable : type;
  680.         switch(theType) {
  681.             case ctrlItem+btnCtrl:
  682. #if !defined(FabSystem7orlater)
  683.                 if (dialogManager7Present)
  684. #endif
  685.                     {
  686.                     if (myRefCon == 1L)
  687.                         (void) SetDialogDefaultItem(dPtr, iNum);
  688.                     else if (myRefCon == 2L)
  689.                         lastItemClosingDialog = iNum;
  690.                     if (iNum == cancel)
  691.                         (void) SetDialogCancelItem(dPtr, iNum);
  692.                     }
  693.                 break;
  694.             case ctrlItem+chkCtrl:
  695.             case ctrlItem+radCtrl:
  696.                 if (myRefCon > 0) {
  697.                     SetControlValue((ControlHandle)item, 1);
  698.                     if (userProc)
  699.                         userProc(dPtr, item, iNum);
  700.                     }
  701. /*                else if (myRefCon == 0) {
  702.                     if (userProc)
  703.                         userProc(dPtr, item, iNum);
  704.                     }*/
  705.                 else if (myRefCon < 0)
  706.                     HiliteControl((ControlHandle)item, 255);
  707.                 break;
  708.             case ctrlItem+resCtrl:
  709.                 if (myRefCon)
  710.                     SetControlValue((ControlHandle)item, myRefCon);
  711.                 break;
  712.             case statText:
  713.                 if (myRefCon)
  714.                     SetDialogItemText(item, (StringPtr)myRefCon);
  715.                 break;
  716.             case editText:
  717.                 SetDialogItemText(item, (StringPtr)myRefCon);
  718.                 if(editTextExists == false) {
  719.                     SelectDialogItemText(dPtr, iNum, 0, SHRT_MAX);
  720.                     editTextExists = true;
  721.                     }
  722.                 break;
  723.     //        case iconItem:
  724.     //            break;
  725.     //        case picItem:
  726.     //            break;
  727.             case userItem:
  728.                 SetDialogItem(dPtr, iNum, type, (Handle)myRefCon, &box);
  729.                 break;
  730.             }
  731.         spanPtr++;
  732.         }
  733. #if !defined(FabSystem7orlater)
  734.     if (dialogManager7Present)
  735. #endif
  736.         (void) SetDialogTracksCursor(dPtr, editTextExists);
  737.     if (initProc)
  738.         initProc(dPtr);
  739.     ShowWindow(GetDialogWindow(dPtr));
  740.     
  741. #pragma mark Event Loop
  742.     
  743.     dialoging = true;
  744.     do {
  745.         ModalDialog(filterProcUPP, &theItemHit);
  746.         if (theItemHit) {
  747.             GetDialogItem(dPtr, theItemHit, &type, &item, &box);
  748.             switch (type) {
  749.                 case ctrlItem+btnCtrl:
  750.                     if ((theItemHit >= ok) && (theItemHit <= lastItemClosingDialog))
  751.                         dialoging = false;
  752.                     else if (userProc)
  753.                         userProc(dPtr, item, theItemHit);
  754.                     break;
  755.                 case ctrlItem+chkCtrl:
  756.                     SetControlValue((ControlHandle)item, 1 - GetControlValue((ControlHandle)item));
  757.                     if (userProc)
  758.                         userProc(dPtr, item, theItemHit);
  759.                     break;
  760.                 case ctrlItem+radCtrl:
  761.                     if (GetControlValue((ControlHandle)item) == 0) {
  762.                         SetControlValue((ControlHandle)item, 1);
  763.                         for (spanPtr = things; (++spanPtr)->itemNumber != theItemHit; )
  764.                             ;
  765.                         itemToBeActivated = spanPtr;
  766.                         for (theGroup = spanPtr->group; (--spanPtr)->group == theGroup; )
  767.                             ;
  768.                         while ((++spanPtr)->refCon <= 0L)
  769.                             ;
  770.                         GetDialogItem(dPtr, spanPtr->itemNumber, &type, &item, &box);
  771.                         SetControlValue((ControlHandle)item, 0);
  772.                         spanPtr->refCon = 0L;
  773.                         itemToBeActivated->refCon = 1L;
  774.                         if (userProc)
  775.                             userProc(dPtr, item, theItemHit);
  776.                         }
  777.                     break;
  778.                 case ctrlItem+resCtrl:
  779.                 case editText:
  780.                     if (userProc)
  781.                         userProc(dPtr, item, theItemHit);
  782.                     break;
  783.                 }
  784.             }
  785.         }
  786.     while (dialoging);
  787.     
  788. #pragma mark Return Settings
  789.     
  790.     if (theItemHit == ok) {
  791.         spanPtr = things;
  792.         while (iNum = spanPtr->itemNumber) {
  793.             GetDialogItem(dPtr, iNum, &type, &item, &box);
  794.             theType = type & itemDisable ? type - itemDisable : type;
  795.             switch(theType) {
  796.                 case ctrlItem+chkCtrl:
  797.                 case ctrlItem+resCtrl:
  798.                     spanPtr->refCon = GetControlValue((ControlHandle)item);
  799.                     break;
  800.                 case editText:
  801.                     GetDialogItemText(item, (StringPtr)spanPtr->refCon);
  802.                     break;
  803.         //        case iconItem:
  804.         //            break;
  805.         //        case picItem:
  806.         //            break;
  807.         //        case userItem:
  808.         //            break;
  809.                 }
  810.             spanPtr++;
  811.             }
  812.         }
  813.     DisposeDialog(dPtr);
  814.     SetPort(port);
  815.     }
  816. else
  817.     SysBeep(30);
  818. if (filterProcUPP)
  819.     DisposeRoutineDescriptor(filterProcUPP);
  820. InitCursor();
  821. return theItemHit;
  822. }
  823.  
  824. /* About box manager */
  825.  
  826. #if    !defined(FabNoSegmentDirectives)
  827. #pragma segment About
  828. #endif
  829.  
  830. /* myAbout: the events directed against the about box are checked with
  831. EventAvail, so that we can discard the about box and process
  832. important events later in the main event loop */
  833.  
  834. void myAbout(void (*theIdleProc)(void),
  835.             UserItemUPP DrawQTPict,
  836.             void (*UpdateProc)(EventRecord *),
  837.             void (*ActivateProc)(EventRecord *)
  838.             )
  839. {
  840. EventRecord    evrec;
  841. DialogPtr    agh, dPtr;
  842. short    iHit;
  843. register Handle    splash;
  844. register Boolean    exit = false;
  845.  
  846. splash = OpenSplash(&agh, DrawQTPict);
  847. if (splash) {
  848.     ShowWindow(GetDialogWindow(agh));
  849.     do {
  850.         SystemTask();
  851.         if (EventAvail(everyEvent, &evrec)) {
  852.             switch(evrec.what) {
  853.                 case mouseDown:
  854.                 case keyDown:
  855.                 case autoKey:
  856.                     exit = true;
  857.                     FlushEvents(mDownMask | mUpMask | keyDownMask | autoKeyMask, 0);
  858.                     break;
  859.                 case mouseUp:
  860.                     (void)GetNextEvent(mUpMask, &evrec);
  861.                     break;
  862.                 case updateEvt :
  863.                     (void)GetNextEvent(updateMask, &evrec);
  864.                     if ((DialogPtr)evrec.message == agh) {
  865.                         BeginUpdate(GetDialogWindow(agh));
  866.                         UpdateDialog(agh, agh->visRgn);
  867.                         EndUpdate(GetDialogWindow(agh));
  868.                         }
  869.                     else
  870.                         if (IsDialogEvent(&evrec))
  871.                             (void) DialogSelect(&evrec, &dPtr, &iHit);
  872.                         else
  873.                             UpdateProc(&evrec);
  874.                     break;
  875.                 case diskEvt :
  876.                 case osEvt :
  877.                 case kHighLevelEvent:
  878.                     exit = true;
  879.                     break;
  880.                 case activateEvt :
  881.                     (void)GetNextEvent(activMask, &evrec);
  882.                     if ((DialogPtr)evrec.message != agh) {
  883.                         if (IsDialogEvent(&evrec))
  884.                             (void) DialogSelect(&evrec, &dPtr, &iHit);
  885.                         else
  886.                             ActivateProc(&evrec);
  887.                         }
  888.                     break;
  889. //                case driverEvt :
  890. //                    (void)GetNextEvent(driverMask, &evrec);
  891. //                    break;
  892.                 }
  893.             }
  894.         else {
  895.             theIdleProc();
  896.             }
  897.         }
  898.     while (exit == false);
  899.     DisposeSplash(splash, agh);
  900.     }
  901. else
  902.     SysBeep(30);
  903. }
  904.  
  905. /* OpenSplash: puts up the about window */
  906.  
  907. Handle OpenSplash(DialogPtr * const pass, UserItemUPP DrawQTPict)
  908. {
  909. enum {
  910. kDLOG_About = 256,
  911. kItemPICT = 1
  912. };
  913.  
  914. Str15    tempS = "\p";
  915. Rect    box;
  916. register DialogPtr    dPtr;
  917. register VersRecHndl    myvers;
  918. register Handle    hand;
  919. Handle    item;
  920. short    type;
  921.  
  922. hand = NewHandle(sizeof(DialogRecord));
  923. if (hand) {
  924.     HLockHi(hand);
  925.     myvers = (VersRecHndl)Get1Resource('vers', 1);
  926.     if (myvers) {
  927.         TruncPString(tempS, (*myvers)->shortVersion, 15);
  928.         ReleaseResource((Handle)myvers);
  929.         }
  930.     else
  931.         tempS[0] = 0;
  932.     ParamText((ConstStr255Param)&tempS, nil, nil, nil);
  933.     *pass = dPtr = GetNewDialog(kDLOG_About, *hand, (WindowRef)-1L);
  934.     if (dPtr) {
  935.         if (DrawQTPict) {
  936.             GetDialogItem(dPtr, kItemPICT, &type, &item, &box);
  937.             SetDialogItem(dPtr, kItemPICT, type, (Handle)DrawQTPict, &box);
  938.             }
  939.         }
  940.     else {
  941.         DisposeHandle(hand);
  942.         hand = nil;
  943.         }
  944.     }
  945. return(hand);
  946. }
  947.  
  948. /* DisposeSplash: gets rid of the about window */
  949.  
  950. void DisposeSplash(Handle dialog, DialogPtr pass)
  951. {
  952. // causes a bus error, time to reread Stuart's Technote...
  953. //DisposeHandle(((DialogPeek)pass)->items);    // see Stuart Cheshire's "Dialog Manager" note
  954.  
  955.  
  956. CloseDialog(pass);
  957. DisposeHandle(dialog);
  958. }
  959.  
  960. void myMovableModalAbout(
  961.             Point *aboutTopLeft,
  962.             Point *creditsTopLeft,
  963.             void (*AdjustMenus)(TEHandle),
  964.             void (*Handle_My_Menu)(long),
  965.             void (*DomyKeyEvent)(EventRecord *),
  966.             void (*DoUpdate)(EventRecord *),
  967.             void (*DoActivate)(EventRecord *),
  968.             void (*DoHiLevEvent)(EventRecord *),
  969.             void (*DoOSEvent)(EventRecord *),
  970.             void (*DoIdle)(void),
  971.             unsigned long minSleep
  972.             )
  973. {
  974. Str15    tempS = "\p";
  975. dialogItems    things[] = {{ ok, 0, 1L },
  976.                         { cancel, 0, 0L },
  977.                         { 0, 0, 0L}
  978.                         };
  979. dialogItems    credits[] = {{ ok, 0, 1L },
  980.                         { 0, 0, 0L}
  981.                         };
  982. VersRecHndl    myvers;
  983.  
  984. myvers = (VersRecHndl)Get1Resource('vers', 1);
  985. if (myvers) {
  986.     TruncPString(tempS, (*myvers)->shortVersion, 15);
  987.     ReleaseResource((Handle)myvers);
  988.     }
  989. else
  990.     StrLength(tempS) = 0;
  991. ParamText((ConstStr255Param)&tempS, nil, nil, nil);
  992. switch (HandleMovableModalDialog((dialogItemsPtr)&things, aboutTopLeft, nil, nil, nil, nil, nil,
  993.             AdjustMenus,
  994.             Handle_My_Menu,
  995.             DomyKeyEvent,
  996.             nil,
  997.             nil,
  998.             DoUpdate,
  999.             DoActivate,
  1000.             DoHiLevEvent,
  1001.             DoOSEvent,
  1002.             DoIdle,
  1003.             minSleep,
  1004.             kDLOG_MovableAbout)) {
  1005.     case ok:
  1006.         break;
  1007.     case cancel:
  1008.         (void) HandleMovableModalDialog((dialogItemsPtr)&credits, creditsTopLeft, nil, nil, nil, nil, nil,
  1009.             AdjustMenus,
  1010.             Handle_My_Menu,
  1011.             DomyKeyEvent,
  1012.             nil,
  1013.             nil,
  1014.             DoUpdate,
  1015.             nil,    //DoActivate,
  1016.             DoHiLevEvent,
  1017.             DoOSEvent,
  1018.             DoIdle,
  1019.             minSleep,
  1020.             kDLOG_MovableCredits);
  1021.         break;
  1022.     }
  1023. }
  1024.  
  1025. #if    !defined(FabNoSegmentDirectives)
  1026. #pragma segment Main
  1027. #endif
  1028.  
  1029. #if defined(powerc) || defined (__powerc)
  1030. SignedByte WantThisHandleSafe(Handle myH)
  1031. {
  1032. SignedByte    cMemTags;
  1033.  
  1034. cMemTags = HGetState(myH);
  1035. HLockHi(myH);
  1036. return cMemTags;
  1037. }
  1038.  
  1039. int AMultBDivC(int a, int b, int c)
  1040. {
  1041. return a * b / c;
  1042. }
  1043.  
  1044. #endif
  1045.  
  1046.  
  1047. void CopyEMailAddrToClip(void)
  1048. {
  1049. CommonCopyToClip(kSTR_EMAILADDR);
  1050. }
  1051.  
  1052. void CopyWWWURLToClip(short menuItem)
  1053. {
  1054. CommonCopyToClip(kSTR_WWWURLHOME - 1 + menuItem);
  1055. }
  1056.  
  1057. void CommonCopyToClip(short id)
  1058. {
  1059. StringHandle    theStr;
  1060.  
  1061. if (theStr = GetString(id)) {
  1062.     if (noErr == ZeroScrap()) {
  1063.         HLockHi((Handle)theStr);
  1064.         (void) PutScrap(**theStr, 'TEXT', *theStr + 1);
  1065.         HUnlock((Handle)theStr);
  1066.         }
  1067.     (void)TEFromScrap();
  1068.     }
  1069. }
  1070.  
  1071. /* GetFontNumber: gets font number from font name */
  1072.  
  1073. Boolean GetFontNumber(ConstStr255Param fontName, short * const fontNum)
  1074. {
  1075. Str255    systemFontName;
  1076. register Boolean    retFlag;
  1077.  
  1078. GetFNum(fontName, fontNum);
  1079. if ((retFlag = (*fontNum != 0)) == false) {
  1080.     GetFontName(0, systemFontName);
  1081.     retFlag = EqualString(fontName, systemFontName, false, false);
  1082.     }
  1083. return retFlag;
  1084. }
  1085.  
  1086. /* other useful stuff to detect keypresses */
  1087.  
  1088. Boolean CmdPeriodOrEsc(const EventRecord * const theEvent)
  1089. {
  1090. return ((unsigned short)theEvent->message == kEscapeKey) || CmdPeriod(theEvent);
  1091. }
  1092.  
  1093. Boolean CmdPeriodOrEscConfirm(const EventRecord * const theEvent, short alertID, ModalFilterProcPtr filterProc)
  1094. {
  1095. register Boolean    retflag;
  1096.  
  1097. retflag = CmdPeriodOrEsc(theEvent);
  1098. if (retflag)
  1099.     retflag = CautionAlert_UPP(alertID, filterProc) == cancel;
  1100. return retflag;
  1101. }
  1102.  
  1103. #if    !defined(FabNoSegmentDirectives)
  1104. #pragma segment Registration
  1105. #endif
  1106.  
  1107. UInt16 gHowManyDollars;
  1108.  
  1109. /* RegistrationFilter: the filter filters entered characters, of course */
  1110.  
  1111. static void RegInitProc(DialogPtr myDPtr);
  1112. static Boolean RegistrationPreProcessKey(EventRecord *thEv, DialogPtr theD);
  1113. static void RegistrationPostProcessKey(EventRecord *thEv, DialogPtr theD);
  1114.  
  1115. Boolean RegistrationPreProcessKey(EventRecord *thEv, DialogPtr theD)
  1116. {
  1117. enum {
  1118. //kBackspaceKey = 8,
  1119. kMaxCopiesChars = 8
  1120. };
  1121.  
  1122. Str255    tempStr;
  1123. Rect    tempRect;
  1124. Handle    ih;
  1125. //short    theItem = GetDialogKeyboardFocusItem(theD);
  1126. short    null;
  1127. short    iHit;
  1128. unsigned char    keypressed;
  1129. Boolean    result = true;
  1130.  
  1131. keypressed = CHARFROMMESSAGE(thEv->message);
  1132. iHit = GetDialogKeyboardFocusItem(theD);
  1133. if (iHit == kItemQuantity) {
  1134.     if (keypressed >= 32 && ((thEv->modifiers & cmdKey) == 0)) {
  1135.         result = ( Munger((Handle)GetString(kSTR_RegDECALLOWED), 1L,
  1136.                         &keypressed, 1L, 0L, 0L) >= 0L );
  1137.         if (result) {
  1138.             GetDialogItem(theD, iHit, &null, &ih, &tempRect);
  1139.             GetDialogItemText(ih, tempStr);
  1140.             if (StrLength(tempStr) >= kMaxCopiesChars) {
  1141.                 (void)StopAlert_UPP(kALRT_WOWTHATMANYCOPIES, nil);
  1142.                 result = false;
  1143.                 }
  1144.             }
  1145.         }
  1146.     }
  1147. return result;
  1148. }
  1149.  
  1150. void RegistrationPostProcessKey(EventRecord */*thEv*/, DialogPtr theD)
  1151. {
  1152. short    theItem = GetDialogKeyboardFocusItem(theD);
  1153.  
  1154. if (theItem == kItemQuantity)
  1155.     RegInitProc(theD);
  1156. }
  1157.  
  1158. void HandleRegistration(/*ModalFilterProcPtr filterProc,*/
  1159.                         Point *regDTopLeft,
  1160.                         long (*regCfgInfo)(Handle, long, StringPtr),
  1161.                         void (*AdjustMenus)(TEHandle),
  1162.                         void (*Handle_My_Menu)(long),
  1163.                         void (*DomyKeyEvent)(EventRecord *),
  1164.                         void (*DoUpdate)(EventRecord *),
  1165.                         void (*DoActivate)(EventRecord *),
  1166.                         void (*DoHiLevEvent)(EventRecord *),
  1167.                         void (*DoOSEvent)(EventRecord *),
  1168.                         void (*DoIdle)(void),
  1169.                         UInt32 minSleep,
  1170.                         UInt16 howManyDollars)
  1171. {
  1172. enum {
  1173. kNumStrings = 13,
  1174. kMyRegText = 256
  1175. };
  1176.  
  1177. StringPtr    regInfo[kNumStrings];
  1178. StdFileResult    theChosenFile;
  1179. ParamBlockRec    myPB;
  1180. EventRecord    dummyEv;
  1181. Str63    tempS = "\p";
  1182. UInt32    quantity;
  1183. short    tmpFRefN;
  1184. const short    zero = 0x0130;
  1185. const short    dash = 0x012D;
  1186. const char    optspace = 'Δ';
  1187. Handle    regText;
  1188. VersRecHndl    myvers;
  1189. StringHandle    sh;
  1190. StringPtr    myAppName = nil;
  1191. long    lOffset;
  1192. int    i;
  1193. OSErr    err;
  1194. SignedByte    savedState;
  1195.  
  1196. dialogItems    things[] = {{ ok, 0, 0L },
  1197.                         { cancel, 0, 0L },
  1198.                         { kItemUserName, 0, 0L },
  1199.                         { kItemCompany, 0, 0L },
  1200.                         { kItemAddress, 0, 0L },
  1201.                         { kItemCity, 0, 0L },
  1202.                         { kItemState, 0, 0L },
  1203.                         { kItemZIP, 0, 0L },
  1204.                         { kItemCountry, 0, 0L },
  1205.                         { kItemE_mail, 0, 0L },
  1206.                         { kItemPhone, 0, 0L },
  1207.                         { kItemFAX, 0, 0L },
  1208.                         { kItemQuantity, 0, 0L },
  1209.                         { kItemCopyFrom, 0, 0L },
  1210.                         { kItemComments, 0, 0L },
  1211.                         { 0, 0, 0L}
  1212.                         };
  1213.  
  1214. lOffset = (long)NewPtrClear(kNumStrings * sizeof(Str255));
  1215. if (lOffset) {
  1216.     things[kItemUserName-1].refCon = lOffset;
  1217.     regInfo[0] = (StringPtr)lOffset;
  1218.     lOffset += (kNumStrings - 1) * sizeof(Str255);
  1219.     for (i = kItemComments - 1; i >= kItemCompany - 1; i--, lOffset -= sizeof(Str255)) {
  1220.         things[i].refCon = lOffset;
  1221.         regInfo[i-2] = (StringPtr)lOffset;
  1222.         }
  1223.     
  1224.     (void)PLstrcpy((StringPtr)things[kItemQuantity-1].refCon, "\p2");
  1225.     
  1226.     gHowManyDollars = howManyDollars;
  1227.     sh = GetString(kSTR_ApplicationName);
  1228.     if (sh) {
  1229.         savedState = WantThisHandleSafe((Handle)sh);
  1230.         myAppName = *sh;
  1231.         }
  1232.     
  1233.     ParamText(myAppName, (ConstStr255Param)&zero, (ConstStr255Param)&zero, nil);
  1234.     if (sh)
  1235.         HSetState((Handle)sh, savedState);
  1236.     do
  1237.         if (HandleMovableModalDialog((dialogItemsPtr)&things, regDTopLeft, nil, nil, RegInitProc, nil, nil,
  1238.                 AdjustMenus,
  1239.                 Handle_My_Menu,
  1240.                 DomyKeyEvent,
  1241.                 RegistrationPreProcessKey,
  1242.                 RegistrationPostProcessKey,
  1243.                 DoUpdate,
  1244.                 DoActivate,
  1245.                 DoHiLevEvent,
  1246.                 DoOSEvent,
  1247.                 DoIdle,
  1248.                 minSleep,
  1249.                 kDLOG_Register) == ok)
  1250.             do {
  1251.                 if ((err = AskForDestFile(&theChosenFile, nil, nil)) == dupFNErr) {
  1252.                     InitCursor();
  1253.                     (void)StopAlert(kALRT_REGCANNOTREPLACE, nil);
  1254.                     }
  1255.                 }
  1256.             while (err == dupFNErr);
  1257.         else
  1258.             err = dupFNErr;
  1259.     while (err == userCanceledErr);
  1260.     if (err == noErr) {
  1261.         regText = Get1Resource('TEXT', kMyRegText);
  1262.         if (regText) {
  1263.             DetachResource(regText);
  1264.             myvers = (VersRecHndl)Get1Resource('vers', 1);
  1265.             if (myvers) {
  1266.                 (void) PLstrcpy(tempS, (*myvers)->shortVersion);
  1267.                 ReleaseResource((Handle)myvers);
  1268.                 }
  1269.             lOffset = Munger(regText, 0L, &optspace, 1L, &tempS[1], tempS[0]);
  1270.             for (i = kItemUserName-3; i <= kItemFAX-3; i++)
  1271.                 lOffset = Munger(regText, lOffset, &optspace, 1L, ®Info[i][1], regInfo[i][0]);
  1272.             for (i = kItemCopyFrom-3; i <= kItemComments-3; i++)
  1273.                 lOffset = Munger(regText, lOffset, &optspace, 1L, ®Info[i][1], regInfo[i][0]);
  1274.             
  1275.             lOffset = RegisterStdConfigInfo(regText, lOffset, tempS);
  1276.             /* custom configuration */
  1277.             if (regCfgInfo)
  1278.                 lOffset = regCfgInfo(regText, lOffset, tempS);
  1279.             
  1280.             /* quantity */
  1281.             lOffset = Munger(regText, lOffset, &optspace, 1L, ®Info[kItemQuantity-3][1], regInfo[kItemQuantity-3][0]);
  1282.             StringToNum(regInfo[kItemQuantity-3], (long *)&quantity);
  1283.             MyNumToString(offer(howManyDollars, quantity), tempS);
  1284.     //        UnloadSeg(sqrt);
  1285.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1286.             IUDateString(LMGetTime(), longDate, tempS);
  1287.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1288. // 6
  1289.             if ((err = FSpCreateCompat(&theChosenFile.destFile, 'ttxt', 'TEXT', theChosenFile.theScript)) == noErr) {
  1290.                 if ((err = FSpOpenDFCompat(&theChosenFile.destFile, fsWrPerm, &tmpFRefN)) == noErr) {
  1291. // 6
  1292.                     HLockHi(regText);
  1293.                     myPB.ioParam.ioCompletion = nil;
  1294.                     myPB.ioParam.ioBuffer = *regText;
  1295.                     myPB.ioParam.ioReqCount = InlineGetHandleSize(regText);
  1296.                     myPB.ioParam.ioPosMode = fsFromStart | kNoCacheMask;
  1297.                     myPB.ioParam.ioRefNum = tmpFRefN;
  1298.                     myPB.ioParam.ioPosOffset = 0L;
  1299.                     (void)PBWriteAsync(&myPB);
  1300.                     while (myPB.ioParam.ioResult > 0) {
  1301.                         SystemTask();
  1302.                         (void)EventAvail(everyEvent, &dummyEv);
  1303.                         }
  1304.                     HUnlock(regText);
  1305.                     (void)FSClose(tmpFRefN);
  1306.                     InitCursor();
  1307.                     MyNumToString(myPB.ioParam.ioResult, tempS);
  1308.                     ParamText(theChosenFile.destFile.name, tempS, nil, nil);
  1309.                     if (myPB.ioParam.ioResult == noErr) {
  1310.                         (void) NoteAlert(kALRT_REGSUCCESSSAVED, nil);
  1311.                         }
  1312.                     else if (myPB.ioParam.ioResult == dskFulErr) {
  1313. // 6
  1314.                         (void) FSpDeleteCompat(&theChosenFile.destFile);
  1315. // 6
  1316.                         (void) StopAlert(kALRT_REGDISKFULL, nil);
  1317.                         }
  1318.                     else
  1319.                         (void) StopAlert(kALRT_REGUNKNOWNWRITEERROR, nil);
  1320.                     }
  1321.                 else
  1322.                     (void) StopAlert(kALRT_REGCOULDNOTOPENFORWRITING, nil);
  1323.                 }
  1324.             else
  1325.                 FileCreationError(err);
  1326.             DisposeHandle(regText);
  1327.             }
  1328.         }
  1329.     DisposePtr((Ptr)regInfo[0]);
  1330.     }
  1331. else
  1332.     SysBeep(30);
  1333. }
  1334.  
  1335. void CopyBugReportForm(long (*regCfgInfo)(Handle, long, StringPtr))
  1336. {
  1337. enum {
  1338. kMyRegText = 257
  1339. };
  1340.  
  1341. Str63    tempS = "\p";
  1342. long    lOffset;
  1343. Handle    regText;
  1344. VersRecHndl    myvers;
  1345. const char    optspace = 'Δ';
  1346.  
  1347. regText = Get1Resource('TEXT', kMyRegText);
  1348. if (regText) {
  1349.     DetachResource(regText);
  1350.     myvers = (VersRecHndl)Get1Resource('vers', 1);
  1351.     if (myvers) {
  1352.         (void) PLstrcpy(tempS, (*myvers)->shortVersion);
  1353.         ReleaseResource((Handle)myvers);
  1354.         }
  1355.     lOffset = Munger(regText, 0L, &optspace, 1L, &tempS[1], tempS[0]);
  1356.     lOffset = RegisterStdConfigInfo(regText, lOffset, tempS);
  1357.     /* custom configuration */
  1358.     if (regCfgInfo)
  1359.         lOffset = regCfgInfo(regText, lOffset, tempS);
  1360.     if (noErr == ZeroScrap()) {
  1361.         HLockHi(regText);
  1362.         (void) PutScrap(InlineGetHandleSize(regText), 'TEXT', *regText);
  1363.         HUnlock(regText);
  1364.         }
  1365.     (void)TEFromScrap();
  1366.     DisposeHandle(regText);
  1367.     }
  1368. }
  1369.  
  1370. long RegisterStdConfigInfo(Handle regText, long curOffset, StringPtr tempS)
  1371. {
  1372. StringPtr    myAppName = nil;
  1373. long    lOffset = curOffset;
  1374. long    resp;
  1375. const short    dash = 0x012D;
  1376. const char    optspace = 'Δ';
  1377.  
  1378. /* Mac model */
  1379. if (Gestalt(gestaltMachineType, &resp) == noErr) {
  1380.     myAppName = GetPtrIndHString(GetResource('STR#', kMachineNameStrID), (unsigned short)(resp - 1L));
  1381.     lOffset = Munger(regText, lOffset, &optspace, 1L, &myAppName[1], myAppName[0]);
  1382.     MyNumToString(resp, tempS);
  1383.     lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1384.     }
  1385. else {
  1386.     lOffset = Munger(regText, lOffset, &optspace, 1L, &((char *)&dash)[1], 1L);
  1387.     lOffset = Munger(regText, lOffset, &optspace, 1L, &((char *)&dash)[1], 1L);
  1388.     }
  1389. /* Sys version */
  1390. if (Gestalt(gestaltSystemVersion, &resp) == noErr) {
  1391.     BCDVersNumToString(resp, tempS);
  1392.     }
  1393. else {
  1394.     *(short *)tempS = dash;
  1395.     }
  1396. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1397. /* Sys Update */
  1398. if (Gestalt('sysu', &resp) == noErr) {
  1399.     BCDLongVersNumToString(resp, tempS);
  1400.     }
  1401. else {
  1402.     *(short *)tempS = dash;
  1403.     }
  1404. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1405. /* addr mode info */
  1406. if (Gestalt(gestaltAddressingModeAttr, &resp) == noErr) {
  1407.     MyNumToString(resp, tempS);
  1408.     }
  1409. else {
  1410.     *(short *)tempS = dash;
  1411.     }
  1412. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1413. /* A/UX info */
  1414. if (Gestalt(gestaltAUXVersion, &resp) == noErr) {
  1415.     BCDVersNumToString(resp, tempS);
  1416.     }
  1417. else {
  1418.     *(short *)tempS = dash;
  1419.     }
  1420. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1421. /* Hardware info */
  1422. if (Gestalt(gestaltHardwareAttr, &resp) == noErr) {
  1423.     MyNumToString(resp, tempS);
  1424.     }
  1425. else {
  1426.     *(short *)tempS = dash;
  1427.     }
  1428. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1429. /* VM info */
  1430. if (Gestalt(gestaltVMAttr, &resp) == noErr) {
  1431.     MyNumToString(resp, tempS);
  1432.     }
  1433. else {
  1434.     *(short *)tempS = dash;
  1435.     }
  1436. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1437. /* Power Manager info */
  1438. if (Gestalt(gestaltPowerMgrAttr, &resp) == noErr) {
  1439.     MyNumToString(resp, tempS);
  1440.     }
  1441. else {
  1442.     *(short *)tempS = dash;
  1443.     }
  1444. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1445. /* Processor type info */
  1446. if (Gestalt(gestaltProcessorType, &resp) == noErr) {
  1447.     MyNumToString(resp, tempS);
  1448.     }
  1449. else {
  1450.     *(short *)tempS = dash;
  1451.     }
  1452. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1453. /* System architecture info */
  1454. if (Gestalt(gestaltSysArchitecture, &resp) == noErr) {
  1455.     MyNumToString(resp, tempS);
  1456.     }
  1457. else {
  1458.     *(short *)tempS = dash;
  1459.     }
  1460. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1461. /* Native processor info */
  1462. if (Gestalt(gestaltNativeCPUtype, &resp) == noErr) {
  1463.     MyNumToString(resp, tempS);
  1464.     }
  1465. else {
  1466.     *(short *)tempS = dash;
  1467.     }
  1468. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1469. /* System 7 tuner info */
  1470. if (Gestalt('bugz', &resp) == noErr) {
  1471.     MyNumToString(resp, tempS);
  1472.     }
  1473. else {
  1474.     *(short *)tempS = dash;
  1475.     }
  1476. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1477. /* Hardware System Updater info */
  1478. if (Gestalt('bugy', &resp) == noErr) {
  1479.     MyNumToString(resp, tempS);
  1480.     }
  1481. else {
  1482.     *(short *)tempS = dash;
  1483.     }
  1484. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1485. /* Hardware System Updater 3 info */
  1486. if (Gestalt('bugx', &resp) == noErr) {
  1487.     MyNumToString(resp, tempS);
  1488.     }
  1489. else {
  1490.     *(short *)tempS = dash;
  1491.     }
  1492. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1493. /* AppleScript info */
  1494. if (Gestalt(gestaltAppleScriptVersion, &resp) == noErr) {
  1495.     BCDLongVersNumToString(resp, tempS);
  1496.     }
  1497. else {
  1498.     *(short *)tempS = dash;
  1499.     }
  1500. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1501. /* QuickTime info */
  1502. if (Gestalt(gestaltQuickTimeVersion, &resp) == noErr) {
  1503.     BCDLongVersNumToString(resp, tempS);
  1504.     }
  1505. else {
  1506.     *(short *)tempS = dash;
  1507.     }
  1508. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1509. /* Thread Manager info */
  1510. if (Gestalt(gestaltThreadMgrAttr, &resp) == noErr) {
  1511.     MyNumToString(resp, tempS);
  1512.     }
  1513. else {
  1514.     *(short *)tempS = dash;
  1515.     }
  1516. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1517. /* Display Manager attr */
  1518. if (Gestalt(gestaltDisplayMgrAttr, &resp) == noErr) {
  1519.     MyNumToString(resp, tempS);
  1520.     }
  1521. else {
  1522.     *(short *)tempS = dash;
  1523.     }
  1524. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1525. /* Display Manager version */
  1526. if (Gestalt(gestaltDisplayMgrVers, &resp) == noErr) {
  1527.     MyNumToString(resp, tempS);
  1528.     }
  1529. else {
  1530.     *(short *)tempS = dash;
  1531.     }
  1532. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1533. /* Drag Manager attr */
  1534. if (Gestalt(gestaltDragMgrAttr, &resp) == noErr) {
  1535.     MyNumToString(resp, tempS);
  1536.     }
  1537. else {
  1538.     *(short *)tempS = dash;
  1539.     }
  1540. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1541. /* AE attr */
  1542. if (Gestalt(gestaltAppleEventsAttr, &resp) == noErr) {
  1543.     MyNumToString(resp, tempS);
  1544.     }
  1545. else {
  1546.     *(short *)tempS = dash;
  1547.     }
  1548. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1549. /* Finder attr */
  1550. if (Gestalt(gestaltFinderAttr, &resp) == noErr) {
  1551.     MyNumToString(resp, tempS);
  1552.     }
  1553. else {
  1554.     *(short *)tempS = dash;
  1555.     }
  1556. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1557. /* FS attr */
  1558. if (Gestalt(gestaltFSAttr, &resp) == noErr) {
  1559.     MyNumToString(resp, tempS);
  1560.     }
  1561. else {
  1562.     *(short *)tempS = dash;
  1563.     }
  1564. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1565. /* OS attr */
  1566. if (Gestalt(gestaltOSAttr, &resp) == noErr) {
  1567.     MyNumToString(resp, tempS);
  1568.     }
  1569. else {
  1570.     *(short *)tempS = dash;
  1571.     }
  1572. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1573. /* Standard File attr */
  1574. if (Gestalt(gestaltStandardFileAttr, &resp) == noErr) {
  1575.     MyNumToString(resp, tempS);
  1576.     }
  1577. else {
  1578.     *(short *)tempS = dash;
  1579.     }
  1580. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1581. /* TextEdit attr */
  1582. if (Gestalt(gestaltTEAttr, &resp) == noErr) {
  1583.     MyNumToString(resp, tempS);
  1584.     }
  1585. else {
  1586.     *(short *)tempS = dash;
  1587.     }
  1588. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1589.  
  1590. return lOffset;
  1591. }
  1592.  
  1593. void RegInitProc(DialogPtr myDPtr)
  1594. {
  1595. Str255    textStr, discountStr;
  1596. Rect    iRect;
  1597. //GrafPtr    savePort;
  1598. Handle    iHandle;
  1599. UInt32    qty;
  1600. short    iType;
  1601. //register RgnHandle    updtRgn;
  1602.  
  1603. GetDialogItem(myDPtr, kItemQuantity, &iType, &iHandle, &iRect);
  1604. GetDialogItemText(iHandle, textStr);
  1605. StringToNum(textStr, (long *)&qty);
  1606. MyNumToString(gHowManyDollars * qty, textStr);
  1607. MyNumToString(offer(gHowManyDollars, qty), discountStr);
  1608. //UnloadSeg(sqrt);
  1609. ParamText(nil, textStr, discountStr, nil);
  1610. GetDialogItem(myDPtr, kItemTotals, &iType, &iHandle, &iRect);
  1611. // correggere con InvalRect !!!!
  1612. /*updtRgn = NewRgn();
  1613. if (updtRgn) {
  1614.     RectRgn(updtRgn, &iRect);
  1615.     UpdtDialog(myDPtr, updtRgn);
  1616.     DisposeRgn(updtRgn);
  1617.     }
  1618. */
  1619. //GetPort(&savePort);
  1620. //SetPort(myDPtr);
  1621. //DebugStr("\pInvalRect imminent");
  1622. InvalRect(&iRect);
  1623. //SetPort(savePort);
  1624. }
  1625.  
  1626. OSErr AskForDestFile(StdFileResultPtr whichFile, ConstStr255Param prompt, StringPtr docName)
  1627. {
  1628. StandardFileReply    mySFR;
  1629. register Handle    sH1;
  1630. register Handle    sH2;
  1631. register SignedByte    state1, state2;
  1632. register OSErr    err = userCanceledErr;
  1633.  
  1634. // 6
  1635. FabStandardPutFile(prompt ? prompt : (sH1 = (Handle)GetString(kSTR_RegPROMPT),
  1636.                                         state1 = WantThisHandleSafe(sH1),
  1637.                                         (ConstStr255Param)*sH1),
  1638.                 docName ? docName : (sH2 = (Handle)GetString(kSTR_RegDEFNAME),
  1639.                                     state2 = WantThisHandleSafe(sH2),
  1640.                                     (ConstStr255Param)*sH2),
  1641.                 &mySFR);
  1642. // 6
  1643.  
  1644. if (docName == nil)
  1645.     HSetState(sH2, state2);
  1646. if (prompt == nil)
  1647.     HSetState(sH1, state1);
  1648.  
  1649. if (mySFR.sfGood) {
  1650.     if (mySFR.sfReplacing)
  1651.         err = dupFNErr;
  1652.     else {
  1653.         err = noErr;
  1654.         whichFile->destFile = mySFR.sfFile;
  1655.         whichFile->theScript = mySFR.sfScript;
  1656.         if (docName) {
  1657.             StrLength(docName) = 0;
  1658.             TruncPString(docName, mySFR.sfFile.name, 31);
  1659.             }
  1660.         }
  1661.     }
  1662. return err;
  1663. }
  1664.  
  1665. void BCDVersNumToString(long num, StringPtr str)
  1666. {
  1667. Str15    tmpstr;
  1668. const short    onepoint = 0x012E;
  1669. register long    tmp;
  1670.  
  1671. str[0] = 0;
  1672. tmp = num;
  1673. tmp >>= 8;
  1674. tmp &= 0xFF;
  1675. MyNumToString(tmp, str);
  1676. (void) PLstrcat(str, (StringPtr)&onepoint);
  1677. tmp = num;
  1678. tmp >>= 4;
  1679. tmp &= 0xF;
  1680. MyNumToString(tmp, tmpstr);
  1681. (void) PLstrcat(str, (StringPtr)&tmpstr);
  1682. tmp = num;
  1683. tmp &= 0xF;
  1684. if (tmp) {
  1685.     MyNumToString(tmp, tmpstr);
  1686.     (void) PLstrcat(str, (StringPtr)&onepoint);
  1687.     (void) PLstrcat(str, (StringPtr)&tmpstr);
  1688.     }
  1689. }
  1690.  
  1691. void BCDLongVersNumToString(long num, StringPtr str)
  1692. {
  1693. Str15    tmpstr;
  1694. const short    onepoint = 0x012E;
  1695. const short    devStr = 0x0164;
  1696. const short    alphaStr = 0x0161;
  1697. const short    betaStr = 0x0162;
  1698. const short    releaseStr = 0x0172;
  1699. register long    tmp;
  1700.  
  1701. str[0] = 0;
  1702. tmp = num;
  1703. tmp >>= 24;
  1704. tmp &= 0xFF;
  1705. MyNumToString(tmp, str);
  1706. (void) PLstrcat(str, (StringPtr)&onepoint);
  1707. tmp = num;
  1708. tmp >>= 20;
  1709. tmp &= 0xF;
  1710. MyNumToString(tmp, tmpstr);
  1711. (void) PLstrcat(str, (StringPtr)&tmpstr);
  1712. tmp = num;
  1713. tmp >>= 16;
  1714. tmp &= 0xF;
  1715. if (tmp) {
  1716.     MyNumToString(tmp, tmpstr);
  1717.     (void) PLstrcat(str, (StringPtr)&onepoint);
  1718.     (void) PLstrcat(str, (StringPtr)&tmpstr);
  1719.     }
  1720. tmp = num;
  1721. tmp >>= 8;
  1722. tmp &= 0xFF;
  1723. switch (tmp) {
  1724.     case developStage:
  1725.         (void) PLstrcat(str, (StringPtr)&devStr);
  1726.         break;
  1727.     case alphaStage:
  1728.         (void) PLstrcat(str, (StringPtr)&alphaStr);
  1729.         break;
  1730.     case betaStage:
  1731.         (void) PLstrcat(str, (StringPtr)&betaStr);
  1732.         break;
  1733.     case finalStage:
  1734.         (void) PLstrcat(str, (StringPtr)&releaseStr);
  1735.         break;
  1736.     }
  1737. tmp = num;
  1738. tmp &= 0xFF;
  1739. if (tmp) {
  1740.     MyNumToString(tmp, tmpstr);
  1741.     (void) PLstrcat(str, (StringPtr)&tmpstr);
  1742.     }
  1743. }
  1744.  
  1745. #if    !defined(FabNoSegmentDirectives)
  1746. #pragma segment Init
  1747. #endif
  1748.  
  1749. /* Code from Apple® converted by Stefan Kurth in super-optimized (!) C */
  1750.  
  1751. /* InitGraf is always implemented (trap $A86E). If the trap table is big
  1752.   enough, trap $AA6E will always point to either Unimplemented or some other
  1753.   trap, but will never be the same as InitGraf. Thus, you can check the size
  1754.   of the trap table by asking if the address of trap $A86E is the same as
  1755.   $AA6E. */
  1756.  
  1757. #define NumToolboxTraps    ((GetToolTrapAddress(_InitGraf) == GetToolTrapAddress(0xAA6E)) ? 0x0200 : 0x0400)
  1758.  
  1759. /* Determines the type of a trap based on its trap number. If bit 11 is clear,
  1760.   then it is an OS trap. Otherwise, it is a Toolbox trap. */
  1761. /* OS traps start with A0, Tool with A8 or AA. */
  1762.  
  1763. #define GetTrapType(which)    (((which) & 0x0800) ? ToolTrap : OSTrap)
  1764. #define IsToolTrap(trap)    ((trap) & 0x0800)
  1765.  
  1766. /* Check to see if a given trap is implemented. This is only used by the
  1767.   Initialize routine in this program, so we put it in the Initialize segment.*/
  1768.  
  1769. Boolean TrapAvailable(short theTrap)
  1770. {
  1771. register UniversalProcPtr    theTrapAddress;
  1772. register short    temp;
  1773.  
  1774. temp = theTrap;
  1775. if(IsToolTrap(temp)) {
  1776.     temp &= 0x07FF;
  1777.     if( temp >= NumToolboxTraps)
  1778.         return false;
  1779.     theTrapAddress = GetToolTrapAddress(temp);
  1780.     }
  1781. else
  1782.     theTrapAddress = GetOSTrapAddress(temp);
  1783. return( GetToolTrapAddress(_Unimplemented) != theTrapAddress);
  1784. }
  1785.  
  1786. OSErr InstallRequiredAEHandlers(AEEventHandlerProcPtr myOAPP,
  1787.                                 AEEventHandlerProcPtr myODOC,
  1788.                                 AEEventHandlerProcPtr myPDOC,
  1789.                                 AEEventHandlerProcPtr myQUIT)
  1790. {
  1791. OSErr    err;
  1792.  
  1793. gmyOAPP_UPP = NewAEEventHandlerProc(myOAPP);
  1794. gmyODOC_UPP = NewAEEventHandlerProc(myODOC);
  1795. gmyPDOC_UPP = NewAEEventHandlerProc(myPDOC);
  1796. gmyQUIT_UPP = NewAEEventHandlerProc(myQUIT);
  1797. if(noErr == (err = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, gmyOAPP_UPP, 0, false)))
  1798.     if(noErr == (err = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, gmyODOC_UPP, 0, false)))
  1799.         if(noErr == (err = AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments, gmyPDOC_UPP, 0, false)))
  1800.             if(noErr == (err = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, gmyQUIT_UPP, 0, false)))
  1801.                 ;
  1802.  
  1803. return err;
  1804. }
  1805.  
  1806. // the err parameter cannot be noErr !
  1807.  
  1808. void FileCreationError(OSErr err)
  1809. {
  1810. Str255    s;
  1811.  
  1812. NumToString(err, s);
  1813. ParamText(s, nil, nil, nil);
  1814. switch (err) {
  1815.     case dirFulErr:
  1816.     case dskFulErr:
  1817.         (void) StopAlert_UPP(kALRT_REGDISKFULLCOULDNOTCREATE, nil);
  1818.         break;
  1819.     case wPrErr:
  1820.     case vLckdErr:
  1821.         (void) StopAlert_UPP(kALRT_REGDISKLOCKEDCOULDNOTCREATE, nil);
  1822.         break;
  1823.     case afpAccessDenied:
  1824.         (void) StopAlert_UPP(kALRT_REGACCESSDENIEDCOULDNOTCREATE, nil);
  1825.         break;
  1826.     default:
  1827.         (void) StopAlert_UPP(kALRT_REGWEIRDCOULDNOTCREATE, nil);
  1828.     }
  1829. }
  1830.  
  1831. #endif
  1832.  
  1833.