home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / MacTCP Library 1.1 / UDP⁄TCP Probe ƒ / Source ƒ / UDP Probe.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-04  |  16.8 KB  |  934 lines  |  [TEXT/SPM ]
  1. /*
  2.     UDP Probe.c
  3.     
  4.     Main code for Host Probe.  This is just a simple program that will 'probe' a host using
  5.     UDP.
  6.     
  7.     This was originally could only probe a host using UDP (hence everything is named with UDP ;-)
  8.     As an afterthought I decided to add TCP probing (should be easy, right? ;-) so the code may
  9.     look a little kludgy, but it should work as advertised.
  10.     
  11.     History:
  12.         03/08/94 dn - Created.
  13.         06/27/95 dn - Prepared for initial release.
  14.         06/28/95 dn - Added TCP probing facilities.
  15.         11/28/95 mc - Converted to CodeWarrior
  16. */
  17.  
  18. // System Includes
  19. #include <MyTCPIncludes.h>
  20. #include <Sound.h>
  21. #include <Icons.h>
  22.  
  23. #if defined(SYMANTEC_C)||defined(THINK_C)
  24. #else
  25. #include <stdio.h>
  26. #include <SIOUX.h>
  27. #endif
  28.  
  29. // Local Includes
  30. #include "UDP Probe.h"
  31. #include "Probes.h"
  32.  
  33. Boolean gQuit,gResolverDone;
  34. short gMacTCP;
  35.  
  36. IPAddr gOurAddr;
  37.  
  38. AEEventHandlerUPP gOappUpp,gOdocUpp,gPdocUpp,gQuitUpp;
  39.  
  40. Boolean gUDP=true;
  41.  
  42. // Main Code Entry Point
  43. void main(void){
  44.     OSErr err;
  45.     
  46. #if defined(SYMANTEC_C)||defined(THINK_C)
  47. #else
  48.     SIOUXSettings.initializeTB = FALSE;
  49.     SIOUXSettings.standalone = FALSE;
  50.     SIOUXSettings.setupmenus = FALSE;
  51.     SIOUXSettings.autocloseonquit = FALSE;
  52.     SIOUXSettings.showstatusline = TRUE;
  53. #endif
  54.     err=InitToolbox();
  55.     
  56. #if defined(SYMANTEC_C)||defined(THINK_C)
  57. #else
  58.     printf("\r");
  59.     fflush(stdout);
  60. #endif
  61.     if (err==noErr){
  62.         err=Initialize();
  63.         
  64.         if (err==noErr){
  65.             err=MainLoop();
  66.         }
  67.         
  68.         err=CleanUp();
  69.     }
  70.     
  71.     KillMacTCP();
  72. }
  73.  
  74. // appleevents.h
  75. OSErr InitializeAppleEvents(void){
  76.     OSErr err=noErr;
  77.     
  78.     gOappUpp=NewAEEventHandlerProc(HandleOApp);
  79.     gOdocUpp=NewAEEventHandlerProc(HandleODoc);
  80.     gPdocUpp=NewAEEventHandlerProc(HandlePDoc);
  81.     gQuitUpp=NewAEEventHandlerProc(HandleQuit);
  82.     
  83.     err=AEInstallEventHandler(kCoreEventClass,kAEOpenApplication,gOappUpp, 0, FALSE);
  84.     
  85.     if (err!=noErr)
  86.         return err;
  87.     
  88.     err=AEInstallEventHandler(kCoreEventClass,kAEOpenDocuments,gOdocUpp, 0, FALSE);
  89.     
  90.     if (err!=noErr)
  91.         return err;
  92.     
  93.     err=AEInstallEventHandler(kCoreEventClass,kAEPrintDocuments,gPdocUpp, 0, FALSE);
  94.     
  95.     if (err!=noErr)
  96.         return err;
  97.     
  98.     err=AEInstallEventHandler(kCoreEventClass,kAEQuitApplication,gQuitUpp, 0, FALSE);
  99.     
  100.     return err;
  101. }
  102.  
  103. pascal OSErr HandleOApp(AppleEvent* ae,AppleEvent* reply,long refCon){
  104.     OSErr err=noErr;
  105.     
  106.     err=HandleRequiredParams(ae);
  107.     
  108.     if (err==noErr){
  109.         // do any open application stuff here.
  110.         
  111.         // nothing to do, it has been done in the initialization routines...
  112.         err=NewProbeDialog();
  113.         
  114.     } else
  115.         HandleMissedParams(reply);
  116.     
  117.     return err;
  118. }
  119.  
  120. pascal OSErr HandleODoc(AppleEvent* ae,AppleEvent* reply,long refCon){
  121.     OSErr err=noErr;
  122.     
  123.     err=HandleRequiredParams(ae);
  124.     
  125.     if (err==noErr){
  126.         // do any open document stuff here...
  127.         err=NotHandledEvent(reply);
  128.         
  129.     }
  130.     
  131.     return err;
  132. }
  133.  
  134. OSErr NotHandledEvent(AppleEvent* ae){
  135.     OSErr err;
  136.     
  137.     if (ae->dataHandle!=nil){
  138.         Str255 errStr="\pUDP Probe can't process the event";
  139.         
  140.         err=AEPutParamPtr(ae,keyErrorString,typeChar,(Ptr)&errStr[1],errStr[0]);
  141.     }
  142.     
  143.     return errAEEventNotHandled;
  144. }
  145.  
  146. OSErr HandleMissedParams(AppleEvent* ae){
  147.     OSErr err=noErr;
  148.     
  149.     if (ae->dataHandle!=nil){
  150.         Str255 errStr="\pRequired parameters were not received";
  151.         
  152.         err=AEPutParamPtr(ae,keyErrorString,typeChar,(Ptr)&errStr[1],errStr[0]);
  153.     }
  154.     
  155.     return err;
  156. }
  157.  
  158. pascal OSErr HandlePDoc(AppleEvent* ae,AppleEvent* reply,long refCon){
  159.     OSErr err=noErr;
  160.     
  161.     err=HandleRequiredParams(ae);
  162.     
  163.     if (err==noErr){
  164.         // do any print document stuff here
  165.         err=NotHandledEvent(reply);
  166.     } else
  167.         HandleMissedParams(reply);
  168.     
  169.     return err;
  170. }
  171.  
  172. pascal OSErr HandleQuit(AppleEvent* ae,AppleEvent* reply,long refCon){
  173.     OSErr err=noErr;
  174.     
  175.     err=HandleRequiredParams(ae);
  176.     
  177.     if (err==noErr){
  178.         // do any error free quit stuff here.
  179.     } else
  180.         HandleMissedParams(reply);
  181.     
  182.     gQuit=true;
  183.     
  184.     return noErr; // force to noErr because we don't care about errors...
  185. }
  186.  
  187. OSErr HandleRequiredParams(AppleEvent* ae){
  188.     DescType type;
  189.     Size size;
  190.     OSErr err;
  191.  
  192.     err=AEGetAttributePtr(ae, keyMissedKeywordAttr,typeWildCard, &type,nil, 0, &size);
  193.  
  194.     if (err==errAEDescNotFound){    // you got all the required parameters
  195.         err=noErr;
  196.     } else {
  197.         if (err == noErr)          // you missed a required parameter
  198.             err=errAEParamMissed;
  199.         // else the call to AEGetAttributePtr failed
  200.     }
  201.     
  202.     return err;
  203. }
  204.  
  205. OSErr Initialize(void){
  206.     OSErr err=noErr,serr;
  207.     Handle mbar;
  208.     MenuHandle mh;
  209.     
  210.     // Initialize our application...
  211.     
  212.     // init the globals
  213.     gQuit=false;
  214.     gMacTCP=-1;
  215.     gOurAddr.a.addr=(b_32)0L;
  216.     
  217.     // install our menu bar
  218.     mbar=GetNewMBar(kMBar);
  219.     SetMenuBar(mbar);
  220.     DrawMenuBar();
  221.     mh=GetMHandle(kMApple);
  222.     AddResMenu(mh,'DRVR');
  223.     
  224.     // Initialize the apple events...
  225.     err=InitializeAppleEvents();
  226.     
  227.     if (err==noErr){
  228.         // Initialize TCP & DNR
  229.         err=OpenMacTCP(&gMacTCP,true);
  230.         
  231.         if (err==noErr){
  232.             
  233.             // pass null to use the "Hosts" file in the system folder
  234.             err=OpenResolver((StringPtr)NULL);
  235.             
  236.             if (err==noErr){
  237.                 // Have the resolver, now get our address...
  238.                 GetAddrParamBlock* ip;
  239.                 
  240.                 ip=NewGetIPParmBlkPtr();
  241.                 
  242.                 ip->ioCRefNum=gMacTCP; // the TCP driver refnum global...
  243.                 
  244.                 // get our ip address
  245.                 err=GetMyIPAddr(ip,FALSE); // do it sync...
  246.                 
  247.                 if (err!=noErr){
  248.                     // Sometimes it can return an error, but it can be ignored
  249.                     // if the ioResult field for the IP parm block is noErr.
  250.                     // check the ioResult to be sure...
  251.                     err=ip->ioResult;
  252.                 }
  253.                 
  254.                 if (err==noErr){
  255.                     // continue...
  256.                     
  257.                     InitProbes();
  258.                 } else
  259.                     HandleError("\pError getting local Macintosh address",err);
  260.                 
  261.                 // Done with the GetIPParmBlock
  262.                 DisposeGetIPParmBlkPtr(ip);
  263.             } else
  264.                 HandleError("\pError opening the Resolver",err);
  265.         } else
  266.             HandleError("\pError opening MacTCP",err);
  267.     }
  268.     
  269.     return err;
  270. }
  271.  
  272. pascal void ResolverDone(HostInfoPtr rp,char* userData){
  273.     
  274.     gResolverDone=true;
  275. }
  276.  
  277. OSErr CleanUp(void){
  278.     OSErr err=noErr;
  279.     WindowPtr wind;
  280.     WindowPeek wp;
  281.     
  282. #if defined(SYMANTEC_C)||defined(THINK_C)
  283.     // For some reason Mike didn't like this.
  284.     // I know it is overkill, but I still like to properly
  285.     // clean things up before dying
  286.     // (with all of the strange inits/cdevs out there, something might depend upon this)
  287.     
  288.     // close any open windows
  289.     wind=FrontWindow();
  290.     
  291.     if (wind!=(WindowPtr)0L){
  292.         while (wind!=(WindowPtr)0L){
  293.             wp=(WindowPeek)wind;
  294.             
  295.             if (wp->windowKind<0){
  296.                 // da window
  297.                 CloseDeskAcc(wp->windowKind);
  298.             } else {
  299.                 // get rid of the window...
  300.                 DisposeWindow(wind);
  301.             }
  302.             
  303.             wind=FrontWindow();
  304.         }
  305.     }
  306. #endif
  307.     
  308.     CleanupProbes();
  309.     
  310.     // close DNR
  311.     err=CloseResolver();
  312.     
  313.     // Get rid of the UPPs for our apple event handlers...
  314.     DisposeRoutineDescriptor(gOappUpp);
  315.     DisposeRoutineDescriptor(gOdocUpp);
  316.     DisposeRoutineDescriptor(gPdocUpp);
  317.     DisposeRoutineDescriptor(gQuitUpp);
  318.     
  319.     return err;
  320. }
  321.  
  322. OSErr MainLoop(void){
  323.     OSErr err=noErr;
  324.     EventRecord er;
  325.     Boolean gotEvent;
  326.     
  327.     while (!gQuit){
  328.         err=HandleDataArrivals();
  329.         
  330.         if (err!=noErr)
  331.             break;
  332.             
  333.         gotEvent=WaitNextEvent(everyEvent,&er,60,(RgnHandle)0L); // no null events
  334.         
  335. #if defined(SYMANTEC_C)||defined(THINK_C)
  336. #else
  337.         if (SIOUXHandleOneEvent(&er))
  338.             continue;
  339. #endif
  340.         
  341.         if (gotEvent){
  342.             
  343.             if (IsDialogEvent(&er)){
  344.                 // let the dialog handle it
  345.                 Boolean did;
  346.                 DialogPtr dlg;
  347.                 short item;
  348.                 
  349.                 did=DialogSelect(&er,&dlg,&item);
  350.                 
  351.                 if (did){
  352.                     // we must handle the event for the dialog
  353.                     if (dlg!=(DialogPtr)0L){
  354.                         long ref=GetWRefCon((WindowPtr)dlg);
  355.                         if ((ref=='NebU')||(ref=='NebP')){
  356.                             // it's our dialog...
  357.                             HandleProbeDialog(&er,dlg,item);
  358.                         }
  359.                     }
  360.                 }
  361.             } else {
  362.                 // let the normal routines handle the event
  363.                 err=HandleEvent(&er);
  364.             }
  365.             
  366.             if (err!=noErr){
  367.                 //gQuit=true;
  368.                 HandleError("\pHandleEvent Returns Error",err);
  369.             }
  370.         } else {
  371.             // didn't get a good event, perhaps an event for the dialog to process
  372.             if (IsDialogEvent(&er)){
  373.                 DialogPtr dlg;
  374.                 short part;
  375.                 
  376.                 if (DialogSelect(&er,&dlg,&part)){
  377.                     // needs more work
  378.                     err=HandleProbeDialog(&er,dlg,part);
  379.                 }
  380.             }
  381.         }
  382.     }
  383.     
  384.     return err;
  385. }
  386.  
  387. OSErr HandleProbeDialog(EventRecord* erp,DialogPtr dlg,short item){
  388.     OSErr err=noErr;
  389.     long ref;
  390.     short i;
  391.     Handle h;
  392.     Rect r;
  393.     
  394.     if (dlg==(DialogPtr)0L)
  395.         return paramErr;
  396.     
  397.     ref=GetWRefCon((WindowPtr)dlg);
  398.     
  399.     if ((ref!='NebU')&&(ref!='NebP'))
  400.         return paramErr;
  401.     
  402.     switch (item){
  403.         case 1: // ok button
  404.             // Hide the dialog
  405.             HideWindow((WindowPtr)dlg);
  406.             
  407.             if (ref=='NebU')
  408.                 err=StartProbe(dlg);
  409.             
  410.             // now get rid of the dialog...
  411.             DisposeDialog(dlg);
  412.             
  413.             break;
  414.         case 2: // cancel button
  415.             if (ref=='NebU'){
  416.                 // Hide the dialog
  417.                 HideWindow((WindowPtr)dlg);
  418.                 
  419.                 // now get rid of the dialog...
  420.                 DisposeDialog(dlg);
  421.             }
  422.             break;
  423.         case 11: // udp radio
  424.             if (ref=='NebU'){
  425.                 GetDItem(dlg,11,&i,&h,&r);
  426.                 
  427.                 if (GetCtlValue((ControlHandle)h)==0){
  428.                     // must change
  429.                     SetCtlValue((ControlHandle)h,1);
  430.                     
  431.                     GetDItem(dlg,12,&i,&h,&r);
  432.                     SetCtlValue((ControlHandle)h,0);
  433.                 }
  434.             }
  435.             break;
  436.         case 12: // tcp radio
  437.             if (ref=='NebU'){
  438.                 GetDItem(dlg,12,&i,&h,&r);
  439.                 
  440.                 if (GetCtlValue((ControlHandle)h)==0){
  441.                     // must change
  442.                     SetCtlValue((ControlHandle)h,1);
  443.                     
  444.                     GetDItem(dlg,11,&i,&h,&r);
  445.                     SetCtlValue((ControlHandle)h,0);
  446.                 }
  447.             }
  448.             break;
  449.         default:
  450.             break;
  451.     }
  452.     
  453.     return err;
  454. }
  455.  
  456. // handle any events we get...
  457. OSErr HandleEvent(EventRecord* erp){
  458.     OSErr err=noErr;
  459.     
  460.     switch (erp->what){
  461.         case mouseDown:
  462.             err=HandleMouse(erp);
  463.             break;
  464.         case keyDown:
  465.         case autoKey:
  466.             err=HandleKey(erp);
  467.             break;
  468.         case diskEvt:
  469.             err=HandleDisk(erp);
  470.             break;
  471.         case updateEvt:
  472.             err=HandleUpdate(erp);
  473.             break;
  474.         case activateEvt:
  475.             err=HandleActivateEvt(erp);
  476.             break;
  477.         case kHighLevelEvent:
  478.             err=HandleHighLevelEvent(erp);
  479.             break;
  480.         case osEvt:
  481.             if (erp->message & 0x01000000){
  482.                 if (erp->message & 0x00000001){ // resume event
  483.                     err=HandleActivate(erp);
  484.                 } else {
  485.                     err=HandleDeactivate(erp);
  486.                 }
  487.             }
  488.             
  489.             if ((erp->message & 0xff000000)==0xfa000000){ // mouse moved
  490.                 // you only get this when a non-nil value is passed to WNE
  491.                 err=HandleMouseMoved(erp);
  492.             }
  493.             
  494.             break;
  495.         default:
  496.             break;
  497.     }
  498.     
  499.     return err;
  500. }
  501.  
  502. // use this routine to handle mouse clicks.
  503. OSErr HandleLimitedMouse(EventRecord* erp,short* ppart,Boolean* handled){
  504.     OSErr err=noErr;
  505.     short part;
  506.     WindowPtr wind;
  507.     Point pt,lpt;
  508.     long ms;
  509.     
  510.     pt=erp->where;
  511.     lpt=pt;
  512.     LocalToGlobal(&pt);
  513.     
  514.     part=FindWindow(erp->where,&wind);
  515.     
  516.     *ppart=part;
  517.     
  518.     if (wind==(WindowPtr)0L)
  519.         return noErr;
  520.     
  521.     switch (part){
  522.         case inMenuBar:
  523.         case inDesk:
  524.         case inSysWindow:
  525.             SysBeep(5);
  526.             break;
  527.         case inContent:
  528.             break;
  529.         case inDrag:
  530.             {
  531.                 Rect br;
  532.                 
  533.                 BlockMoveData((Ptr)(&qd.screenBits.bounds),(Ptr)&br,sizeof(Rect));
  534.                 
  535.                 InsetRect(&br,4,4);
  536.                 
  537.                 DragWindow(wind,lpt,&br);
  538.                 *handled=true;
  539.             }
  540.             break;
  541.         case inGoAway:
  542.             // perhaps we should close the window?
  543.             break;
  544.         case inZoomIn:
  545.         case inZoomOut:
  546.             {
  547.                 Boolean sel=true;
  548.                 
  549.                 if (erp->modifiers & cmdKey)
  550.                     sel=false; // don't select if the cmd key is down
  551.                 
  552.                 ZoomWindow(wind,part,sel);
  553.                 *handled=true;
  554.             }
  555.             break;
  556.         default:
  557.             // some weird part was clicked
  558.             // we ignore it...
  559.             SysBeep(5);
  560.             break;
  561.     }
  562.     
  563.     return err;
  564. }
  565.  
  566. OSErr HandleMouse(EventRecord* erp){
  567.     OSErr err=noErr;
  568.     short part;
  569.     WindowPtr wind;
  570.     Point pt,lpt;
  571.     long ms;
  572.     
  573.     pt=erp->where;
  574.     lpt=pt;
  575.     LocalToGlobal(&pt);
  576.     
  577.     part=FindWindow(erp->where,&wind);
  578.     
  579.     switch (part){
  580.         case inMenuBar:
  581.             err=HandleMenuEnabling();
  582.             ms=MenuSelect(lpt);
  583.             err=HandleMenu(ms);
  584.             break;
  585.         case inDesk:
  586.         case inSysWindow:
  587.             SystemClick(erp,wind);
  588.             break;
  589.         case inContent:
  590.             SelectWindow(wind);
  591.             break;
  592.         case inDrag:
  593.             {
  594.                 Rect br;
  595.                 
  596.                 BlockMoveData((Ptr)(&qd.screenBits.bounds),(Ptr)&br,sizeof(Rect));
  597.                 
  598.                 InsetRect(&br,4,4);
  599.                 
  600.                 DragWindow(wind,pt,&br);
  601.             }
  602.             break;
  603.         case inGoAway:
  604.             // we shouldn't get these...
  605.             DisposeWindow(wind);
  606.             break;
  607.         case inZoomIn:
  608.         case inZoomOut:
  609.             {
  610.                 Boolean sel=true;
  611.                 
  612.                 if (erp->modifiers & cmdKey)
  613.                     sel=false; // don't select if the cmd key is down
  614.                 
  615.                 ZoomWindow(wind,part,sel);
  616.             }
  617.             break;
  618.         default:
  619.             // some weird part was clicked
  620.             // we ignore it...
  621.             break;
  622.     }
  623.     
  624.     return err;
  625. }
  626.  
  627. OSErr HandleMenuEnabling(void){
  628.     OSErr err=noErr;
  629.     
  630.     // nothing to activate or deactivate.
  631.     
  632.     return err;
  633. }
  634.  
  635. OSErr HandleMenu(long ms){
  636.     OSErr err=noErr;
  637.     short menu,item;
  638.     
  639.     menu=HiWord(ms);
  640.     item=LoWord(ms);
  641.     
  642.     if (menu!=0){
  643.         // a valid menu choice
  644.         switch (menu){
  645.             case kMApple:
  646.                 err=HandleApple(item);
  647.                 break;
  648.             case kMFile:
  649.                 err=HandleFile(item);
  650.                 break;
  651.             default:
  652.                 // could be an error, but I am ignoring them...
  653.                 break;
  654.         }
  655.     } else {
  656.         ms=MenuChoice();
  657.         
  658.         // ms represents a disabled choice the user picked.
  659.     }
  660.     
  661.     HiliteMenu(0);
  662.     
  663.     return err;
  664. }
  665.  
  666. OSErr HandleError(StringPtr errStr,OSErr err){
  667.     OSErr ierr=noErr;
  668.     Str255 numErr;
  669.     long lerr;
  670.     
  671.     // build the error number string
  672.     lerr=(long)err;
  673.     NumToString(lerr,numErr);
  674.     
  675.     // have paramtext fill in the alert
  676.     ParamText(errStr,numErr,"\p","\p");
  677.     
  678.     // let stopalert display the error message.
  679.     StopAlert(128,(ModalFilterUPP)0L);
  680.     
  681.     return ierr;
  682. }
  683.  
  684. OSErr HandleLongError(StringPtr errStr,long err){
  685.     OSErr ierr=noErr;
  686.     Str255 numErr;
  687.     long lerr;
  688.     
  689.     // build the error number string
  690.     lerr=(long)err;
  691.     NumToString(lerr,numErr);
  692.     
  693.     // have paramtext fill in the alert
  694.     ParamText(errStr,numErr,"\p","\p");
  695.     
  696.     // let stopalert display the error message.
  697.     StopAlert(128,(ModalFilterUPP)0L);
  698.     
  699.     return ierr;
  700. }
  701.  
  702. OSErr HandleApple(short item){
  703.     OSErr err=noErr;
  704.     
  705.     switch (item){
  706.         case kMAbout:
  707.             err=HandleAbout();
  708.             break;
  709.         default:
  710.             // handle da's here
  711.             {
  712.                 MenuHandle mh=GetMHandle(kMApple);
  713.                 Str255 da;
  714.                 GrafPtr savePort;
  715.                 
  716.                 GetItem(mh,item,da);
  717.                 
  718.                 GetPort(&savePort);
  719.                 
  720.                 OpenDeskAcc(da);
  721.                 
  722.                 SetPort(savePort);
  723.             }
  724.             break;
  725.     }
  726.     
  727.     return err;
  728. }
  729.  
  730. OSErr HandleFile(short item){
  731.     OSErr err=noErr;
  732.     
  733.     switch (item){
  734.         case kMProbe:
  735.             err=NewProbeDialog();
  736.             break;
  737.         case kMQuit:
  738.             gQuit=true;
  739.             break;
  740.         default:
  741.             break;
  742.     }
  743.     
  744.     return err;
  745. }
  746.  
  747. OSErr NewProbeDialog(void){
  748.     OSErr err=noErr;
  749.     DialogPtr dlg;
  750.     GrafPtr save;
  751.     short i;
  752.     Handle h;
  753.     Rect r;
  754.     
  755.     GetPort(&save);
  756.     
  757.     dlg=GetNewDialog(128,(Ptr)0L,(WindowPtr)-1);
  758.     
  759.     if (dlg!=(DialogPtr)0L){
  760.         // have the dialog
  761.         SetPort((GrafPtr)dlg);
  762.         
  763.         GetDItem(dlg,11,&i,&h,&r);
  764.         SetCtlValue((ControlHandle)h,1);
  765.         
  766.         GetDItem(dlg,12,&i,&h,&r);
  767.         SetCtlValue((ControlHandle)h,0);
  768.         
  769.         ShowWindow((WindowPtr)dlg);
  770.         
  771.         SelIText(dlg,3,0,30000);
  772.         
  773.         SetWRefCon((WindowPtr)dlg,'NebU');
  774.         
  775.         InvalRect(&(dlg->portRect));
  776.         
  777.         SetPort(save);
  778.     }
  779.     
  780.     return err;
  781. }
  782.  
  783. OSErr HandleEdit(short item){
  784.     OSErr err=noErr;
  785.     
  786.     // This application doesn't use any editing features so they
  787.     // are being ignored...
  788.     
  789.     return err;
  790. }
  791.  
  792. // use this routine to handle key events.
  793. OSErr HandleKey(EventRecord* erp){
  794.     OSErr err=noErr;
  795.     char ch,key;
  796.     long mk;
  797.     
  798.     ch=erp->message&charCodeMask;
  799.     key=(erp->message&keyCodeMask)>>8;
  800.     
  801.     if (erp->modifiers & cmdKey){
  802.         // menu event
  803.         err=HandleMenuEnabling();
  804.         mk=MenuKey(ch);
  805.         err=HandleMenu(mk);
  806.     } else {
  807.         // normal key events
  808.         
  809.         // currently ignored
  810.     }
  811.     
  812.     return err;
  813. }
  814.  
  815. // Handle window activate events here
  816. OSErr HandleActivateEvt(EventRecord* erp){
  817.     OSErr err=noErr;
  818.     WindowPtr wind;
  819.     
  820.     wind=(WindowPtr)erp->message;
  821.     
  822.     if (wind==(WindowPtr)0L)
  823.         return noErr;
  824.     
  825.     if (erp->modifiers&activeFlag){
  826.         BringToFront(wind); // make it the frontmost
  827.         HiliteWindow(wind,true); // activate the window...
  828.     } else {
  829.         HiliteWindow(wind,false); // deactivate the window...
  830.     }
  831.     
  832.     return err;
  833. }
  834.  
  835. // Handle Window Updates
  836. OSErr HandleUpdate(EventRecord* erp){
  837.     OSErr err=noErr;
  838.     WindowPtr wind;
  839.     
  840.     wind=(WindowPtr)erp->message;
  841.     
  842.     if (wind!=(WindowPtr)0L){
  843.         BeginUpdate(wind);
  844.         EndUpdate(wind);
  845.     }
  846.     
  847.     return err;
  848. }
  849.  
  850. // Handle Disk Events here...
  851. OSErr HandleDisk(EventRecord* erp){
  852.     OSErr err=noErr;
  853.     Point pt;
  854.     
  855.     SetPt(&pt,100,100);
  856.     err=(OSErr)DIBadMount(pt,erp->message);
  857.     
  858.     return err;
  859. }
  860.  
  861. // Entry point for Apple Event Handling
  862. OSErr HandleHighLevelEvent(EventRecord* erp){
  863.     OSErr err=noErr;
  864.     
  865.     err=AEProcessAppleEvent(erp);
  866.     
  867.     return err;
  868. }
  869.  
  870. // use this routine to handle activate events...
  871. OSErr HandleActivate(EventRecord* erp){
  872.     OSErr err=noErr;
  873.     WindowPtr wind;
  874.     
  875.     wind=FrontWindow();
  876.     if (wind!=(WindowPtr)0L)
  877.         HiliteWindow(wind,true); // hilite the window
  878.     
  879.     return err;
  880. }
  881.  
  882. // use this routine to handle the deactivate events
  883. OSErr HandleDeactivate(EventRecord* erp){
  884.     OSErr err=noErr;
  885.     WindowPtr wind;
  886.     
  887.     wind=FrontWindow();
  888.     if (wind!=(WindowPtr)0L)
  889.         HiliteWindow(wind,false); // deactivate the window
  890.     
  891.     return err;
  892. }
  893.  
  894. // use this routine to change the mouse cursor depending on where the mouse is located.
  895. OSErr HandleMouseMoved(EventRecord* erp){
  896.     OSErr err=noErr;
  897.     
  898.     return err;
  899. }
  900.  
  901. // Initialize the Mac Toolbox
  902. OSErr InitToolbox(void){
  903.     OSErr err=noErr;
  904.     
  905.     InitGraf((Ptr) &qd.thePort);
  906.     InitFonts();
  907.     InitWindows();
  908.     InitMenus();
  909.     FlushEvents(everyEvent,0);
  910.     TEInit();
  911.     InitDialogs(0L);
  912.     InitCursor();
  913.     
  914.     return err;
  915. }
  916.  
  917. OSErr HandleAbout(void){
  918.     OSErr err=noErr;
  919.     
  920.     ParamText("\p1.0","\p","\p","\p");
  921.     Alert(129,(ModalFilterUPP)0L);
  922.     
  923.     return err;
  924. }
  925.  
  926.  
  927.  
  928.  
  929.  
  930.  
  931.  
  932.  
  933.  
  934.