home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / Think Class Libraries / AE Stuff / CGenericAE.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-30  |  11.7 KB  |  563 lines  |  [TEXT/KAHL]
  1. /*
  2.  * ---------------------------------------------------------------------
  3.  * CGenericAE.c :
  4.  *
  5.  * © Copyright 1992 by F. Menneteau.  All rights reserved.
  6.  * This code can be both distributed and used freely.
  7.  *
  8.  * ---------------------------------------------------------------------
  9.  */
  10.  
  11.  
  12. #include "CGenericAE.h"
  13.  
  14.  
  15. /*************************************************************************
  16.  *    METHOD DEFINITIONS
  17.  *************************************************************************/
  18. CGenericAE::CGenericAE(void)
  19. {
  20.     fEventIsValid = FALSE ;
  21.     fReplyIsValid = FALSE ;
  22.     fDescIsValid  = FALSE ;
  23. }
  24.  
  25.  
  26. CGenericAE::~CGenericAE(void)
  27. {
  28.     if ( fEventIsValid )
  29.         (void) AEDisposeDesc(&itsEvent)    ;
  30.  
  31.     if ( fReplyIsValid )
  32.         (void) AEDisposeDesc(&itsReply) ;
  33.  
  34.     if ( fDescIsValid )
  35.         (void) AEDisposeDesc(&itsAEAddrDesc) ;
  36. }
  37.  
  38.  
  39. Size CGenericAE::strcspn(const Ptr s1, const Ptr s2)
  40. {
  41.     Size    LcSizeResult    ;
  42.  
  43.     asm {
  44.         movea.l    s1,a0        ;  A0 = s1
  45.         moveq    #-1,d0            ;  D0.L = result
  46. @1        addq.l    #1,d0
  47.         move.b    (a0)+,d1
  48.         beq.s    @3
  49.         movea.l    s2,a1        ;  A1 = s2
  50. @2        move.b    (a1)+,d2
  51.         beq.s    @1
  52.         cmp.b    d1,d2
  53.         bne.s    @2
  54. @3        move.l    D0,LcSizeResult
  55.     }
  56.     return(LcSizeResult) ;
  57. }
  58.  
  59.  
  60. OSErr CGenericAE::privBuidTargetDesc(
  61.     TargetInfPtr    TheTargetInfPtr)
  62. {
  63.     char                LcChar         ;
  64.     DescType            LcDescType    ;
  65.     Ptr                    LcPtr        ;
  66.     Size                LcSize        ;
  67.     ProcessSerialNumber    LcPSN         ;
  68.  
  69.     switch ( TheTargetInfPtr->tSelector ) {
  70.     case sTARGET_ID :
  71.         LcDescType    = typeTargetID                            ;
  72.         LcPtr        = (Ptr) &(TheTargetInfPtr->u.tTargetID)    ;
  73.         LcSize        = sizeof(TheTargetInfPtr->u.tTargetID)    ;
  74.         break                                                ;
  75.  
  76.     case sSIGN_ONLY :
  77.         LcDescType    = typeApplSignature                            ;
  78.         LcPtr        = (Ptr) &(TheTargetInfPtr->u.s.tSignature)    ;
  79.         LcSize        = sizeof(TheTargetInfPtr->u.s.tSignature)    ;
  80.         break                                                    ;
  81.  
  82.     case sTYPE_AND_SIGN :
  83.         itsError = GetProcessPSN(TheTargetInfPtr->u.s.tType,
  84.                                 TheTargetInfPtr->u.s.tSignature,&LcPSN) ;
  85.  
  86.         LcDescType    = typeProcessSerialNumber    ;
  87.         LcPtr        = (Ptr) &LcPSN                ;
  88.         LcSize        = sizeof(LcPSN)                ;
  89.         break                                    ;
  90.  
  91.     case sPSN :
  92.         LcDescType    = typeProcessSerialNumber                ;
  93.         LcPtr        = (Ptr) &(TheTargetInfPtr->u.tPSNumber)    ;
  94.         LcSize        = sizeof(TheTargetInfPtr->u.tPSNumber)    ;
  95.         break                                                ;
  96.  
  97.     case sSESSION_ID :
  98.         LcDescType    = typeSessionID                            ;
  99.         LcPtr        = (Ptr) &(TheTargetInfPtr->u.tSessionID);
  100.         LcSize        = sizeof(TheTargetInfPtr->u.tSessionID)    ;
  101.         break                                                ;
  102.  
  103.     default :
  104.         itsError = errAEWrongDataType ;
  105.     }
  106.  
  107.     RETN_IF_ERR(itsError) ;
  108.  
  109.     MyHLock((Handle) this,&LcChar)    ;
  110.  
  111.     if ( fDescIsValid )    { // itsAEAddrDesc was previously initialized
  112.         (void) AEDisposeDesc(&itsAEAddrDesc)    ;
  113.         fDescIsValid = FALSE                    ;
  114.     }
  115.  
  116.     if ( (itsError = AECreateDesc(LcDescType,LcPtr,LcSize,
  117.                                                 &itsAEAddrDesc)) == noErr )
  118.         fDescIsValid = TRUE ;
  119.  
  120.     MyHUnlock((Handle) this,LcChar)    ;
  121.     return(itsError)                ;
  122. }
  123.  
  124.  
  125. OSErr CGenericAE::BuildTargetWithTargetID(
  126.     TargetIDPtr TheTargetIDPtr)
  127. {
  128.     TargetInfo    LcTargetInfo ;
  129.  
  130.     LcTargetInfo.tSelector     = sTARGET_ID        ;
  131.     LcTargetInfo.u.tTargetID = *TheTargetIDPtr    ;
  132.  
  133.     return(privBuidTargetDesc(&LcTargetInfo)) ;
  134. }
  135.  
  136.  
  137. OSErr CGenericAE::BuildTargetWithSignOnly(
  138.     OSType        TheSignature)
  139. {
  140.     TargetInfo    LcTargetInfo ;
  141.  
  142.     LcTargetInfo.tSelector        = sSIGN_ONLY    ;
  143.     LcTargetInfo.u.s.tType        = (OSType) NULL    ;
  144.     LcTargetInfo.u.s.tSignature    = TheSignature    ;
  145.  
  146.     return(privBuidTargetDesc(&LcTargetInfo)) ;
  147. }
  148.  
  149.  
  150. OSErr CGenericAE::BuildTargetWithTypeAndSign(
  151.     OSType        TheType,
  152.     OSType        TheSignature)
  153. {
  154.     TargetInfo    LcTargetInfo ;
  155.  
  156.     LcTargetInfo.tSelector        = sTYPE_AND_SIGN    ;
  157.     LcTargetInfo.u.s.tType        = TheType            ;
  158.     LcTargetInfo.u.s.tSignature    = TheSignature        ;
  159.  
  160.     return(privBuidTargetDesc(&LcTargetInfo)) ;
  161. }
  162.  
  163.  
  164. OSErr CGenericAE::BuildTargetWithPSN(
  165.     ProcessSerialNumberPtr    ThePSNPtr)
  166. {
  167.     TargetInfo    LcTargetInfo ;
  168.  
  169.     LcTargetInfo.tSelector     = sPSN            ;
  170.     LcTargetInfo.u.tPSNumber = *ThePSNPtr    ;
  171.  
  172.     return(privBuidTargetDesc(&LcTargetInfo)) ;
  173. }
  174.  
  175.  
  176. OSErr CGenericAE::BuildTargetWithSessionID(
  177.     PPCSessRefNumPtr    TheSeesionID)
  178. {
  179.     TargetInfo    LcTargetInfo ;
  180.  
  181.     LcTargetInfo.tSelector        = sSESSION_ID    ;
  182.     LcTargetInfo.u.tSessionID    = *TheSeesionID    ;
  183.  
  184.     return(privBuidTargetDesc(&LcTargetInfo)) ;
  185. }
  186.  
  187.  
  188. OSErr CGenericAE::BuildTargetWithRemoteName(
  189.     Ptr    TheRemoteName)
  190. {
  191.     Str31        LcZone            ;
  192.     Str31        LcServer        ;
  193.     Str32        LcTarget        ;
  194.     Size        LcSize            ;
  195.     rPtr        LcPtr            ;
  196.     TargetInfo    LcTargetInfo     ;
  197.  
  198.     /*
  199.      *    Extract from TheRemoteName a Zone, a Server and a Target name
  200.      *    and call the GetTargetID function.
  201.      *
  202.      *    TheRemoteName can have the following forms:
  203.      *        [1] "<zone>:<server>:<target>"
  204.      *        [2] ":<server>:<target>"
  205.      *
  206.      *    If a <zone> is not specified, it means we want to use the
  207.      *    local zone (and that case <zone> must be set to "*").
  208.      */
  209.     LcPtr = TheRemoteName                ;
  210.     PtoCstr((unsigned char *) LcPtr)    ;
  211.  
  212.     if ( LcPtr[0] == *DELIMITER )
  213.         pstrcpy((Ptr) LcZone,(Ptr) "\p*")    ;
  214.     else {
  215.         LcSize = strcspn(LcPtr,DELIMITER)    ;
  216.         BlockMove(LcPtr,&LcZone[1],LcSize)    ;
  217.         *(LcZone) = (char) LcSize            ;
  218.         LcPtr += LcSize                        ;
  219.     }
  220.  
  221.     LcPtr++ ;    // skip the DELIMITER character
  222.  
  223.     if ( (LcSize = strcspn(LcPtr,DELIMITER)) == (Size) 0 )
  224.         return(itsError = afpNoServer)    ;
  225.  
  226.     BlockMove(LcPtr,&LcServer[1],LcSize)    ;
  227.     *(LcServer) = (char) LcSize                ;
  228.     LcPtr += (LcSize + 1)                    ;
  229.  
  230.     CtoPstr(LcPtr)                    ;
  231.     pstrcpy((Ptr) LcTarget,LcPtr)    ;
  232.  
  233.     itsError = GetTargetID(
  234.             LcZone,
  235.             LcServer,
  236.             LcTarget,
  237.             &LcTargetInfo.u.tTargetID) ;
  238.  
  239.     RETN_IF_ERR(itsError) ;
  240.  
  241.     LcTargetInfo.tSelector = sTARGET_ID            ;
  242.     return(privBuidTargetDesc(&LcTargetInfo))    ;
  243. }
  244.  
  245.  
  246. OSErr CGenericAE::AskAndBuildTarget(
  247.     SelectorType TheSelectorType)
  248. {
  249.     PortInfoRec        LcPortInfoRec    ;
  250.     LocationNameRec    LcLocNameRec    ;
  251.     TargetInfo        LcTargetInfo     ;
  252.  
  253.     itsError = PPCBrowser(
  254.             NULL,                        // prompt
  255.             NULL,                        // applListLabel
  256.             FALSE,                        // defaultSpecified
  257.             &LcLocNameRec,                // theLocation
  258.             &LcPortInfoRec,                // thePortInfo
  259.             NULL,                        // PPCFilterProcPtr
  260.             NULL) ;                        // theLocNBPType
  261.  
  262.     RETN_IF_ERR(itsError) ;
  263.  
  264.     LcTargetInfo.tSelector = TheSelectorType ;
  265.  
  266.     switch ( TheSelectorType ) {
  267.     case sTARGET_ID :
  268.         LcTargetInfo.u.tTargetID.sessionID    = 0L                ;
  269.         LcTargetInfo.u.tTargetID.location    = LcLocNameRec        ;
  270.         LcTargetInfo.u.tTargetID.name        = LcPortInfoRec.name;
  271.  
  272.         break ;
  273.  
  274.     case sSIGN_ONLY :
  275.     case sTYPE_AND_SIGN : {
  276.         ProcessInfoRec        LcProcInfoRec    ;
  277.         ProcessSerialNumber    LcPSN            ;
  278.  
  279.         if ( (itsError = GetProcessSerialNumberFromPortName(
  280.                                     &LcPortInfoRec.name,&LcPSN)) != noErr )
  281.             break ;
  282.  
  283.         LcProcInfoRec.processInfoLength    = sizeof(LcProcInfoRec)    ;
  284.         LcProcInfoRec.processName        = (StringPtr) NULL        ;
  285.         LcProcInfoRec.processAppSpec    = (FSSpecPtr) NULL        ;
  286.  
  287.         if ( (itsError = GetProcessInformation(
  288.                                         &LcPSN,&LcProcInfoRec)) != noErr )
  289.             break ;
  290.  
  291.         LcTargetInfo.u.s.tType         = LcProcInfoRec.processType        ;
  292.         LcTargetInfo.u.s.tSignature = LcProcInfoRec.processSignature    ;
  293.  
  294.         if ( TheSelectorType == sSIGN_ONLY )
  295.             LcTargetInfo.u.s.tType = (OSType) NULL ;
  296.     }
  297.  
  298.     case sPSN :
  299.         itsError = GetProcessSerialNumberFromPortName(
  300.                             &LcPortInfoRec.name,&LcTargetInfo.u.tPSNumber) ;
  301.         break ;
  302.  
  303.     case sSESSION_ID :    /* I really don't know how to get a SessionID */
  304.         // FALLS THROUGH NEXT CASE
  305.  
  306.     default :
  307.         LcTargetInfo.tSelector = sNONE    ;
  308.         itsError = errAEWrongDataType    ;
  309.     }
  310.  
  311.     RETN_IF_ERR(itsError)                        ;
  312.     return(privBuidTargetDesc(&LcTargetInfo))    ;
  313. }
  314.  
  315.  
  316. OSErr CGenericAE::CreateAE(
  317.     DescType    TheEventClass,
  318.     DescType    TheEventID)
  319. {
  320.     char    LcChar     ;
  321.  
  322.     if ( !fDescIsValid )
  323.         return(itsError = connectionInvalid) ;
  324.  
  325.     if ( fEventIsValid ) {            // itsEvent was previously initialized
  326.         (void) AEDisposeDesc(&itsEvent)    ;
  327.         fEventIsValid = FALSE            ;
  328.     }
  329.  
  330.     MyHLock((Handle) this,&LcChar) ;
  331.  
  332.     itsError = AECreateAppleEvent(
  333.         TheEventClass,
  334.         TheEventID,
  335.         &itsAEAddrDesc,
  336.         kAutoGenerateReturnID,
  337.         kAnyTransactionID,
  338.         &itsEvent) ;
  339.  
  340.     MyHUnlock((Handle) this,LcChar) ;
  341.     RETN_IF_ERR(itsError)            ;
  342.  
  343.     fEventIsValid = TRUE        ;
  344.     return(itsError = noErr)    ;
  345. }
  346.  
  347.  
  348. OSErr CGenericAE::protPutParam(
  349.     AEKeyword    theAEKeyword,
  350.     DescType    TheTypeCode,
  351.     Ptr            TheDataPtr,
  352.     Size        TheDataSize)
  353. {
  354.     char    LcChar ;
  355.  
  356.     if ( !fEventIsValid )
  357.         return(itsError = errAENotAEDesc) ;
  358.  
  359.     MyHLock((Handle) this,&LcChar)    ;
  360.  
  361.     itsError = AEPutParamPtr(
  362.                 &itsEvent,theAEKeyword,TheTypeCode,TheDataPtr,TheDataSize) ;
  363.  
  364.     MyHUnlock((Handle) this,LcChar)    ;
  365.     return(itsError)                ;
  366. }
  367.  
  368.  
  369. OSErr CGenericAE::protFolderPathPutParam(
  370.     Ptr                TheFolderPath)        // Can be a disk name
  371. {
  372.     char            LcChar             ;
  373.     AliasHandle        LcFolderAlias    ;
  374.  
  375.     if ( !fEventIsValid )
  376.         return(itsError = errAENotAEDesc) ;
  377.  
  378.     itsError = EntityPathToAlias(TheFolderPath,typeFOLDER,&LcFolderAlias);
  379.     RETN_IF_ERR(itsError)                                                 ;
  380.  
  381.     MyHLock((Handle) this,&LcChar)    ;
  382.     HLock((Handle) LcFolderAlias)    ;
  383.  
  384.     itsError = AEPutParamPtr(
  385.         &itsEvent,
  386.         keyDirectObject,
  387.         typeAlias,
  388.         (Ptr) *LcFolderAlias,
  389.         (**LcFolderAlias).aliasSize) ;
  390.  
  391.     HUnlock((Handle) LcFolderAlias)            ;
  392.     DisposHandle((Handle) LcFolderAlias)    ;
  393.     MyHUnlock((Handle) this,LcChar)            ;
  394.  
  395.     return(itsError) ;
  396. }
  397.  
  398.  
  399. OSErr CGenericAE::protFilesListPutParam(
  400.     Ptr                TheFolderPath,        // can be empty
  401.     Ptr                TheFileList)        // comma delimited list of names. 
  402. {
  403.     Str255            LcFolderPath    ;
  404.     Str255            LcFullPathName    ;
  405.     Str255            LcFileList        ;
  406.     AEDescList        LcAEDescList    ;
  407.     AliasHandle        LcFileAlias        ;
  408.     rPtr            LcFilePtr        ;
  409.     register Size    LcSize            ;
  410.     rint            LcCount            ;
  411.     char            LcChar             ;
  412.  
  413.     if ( !fEventIsValid )
  414.         return(itsError = errAENotAEDesc) ;
  415.  
  416.     itsError = AECreateList((Ptr) NULL,(Size) 0,FALSE,&LcAEDescList)    ;
  417.     RETN_IF_ERR(itsError)                                                ;
  418.  
  419.     /*
  420.      *    Save folder name because we can modify it.
  421.      */
  422.     if ( TheFolderPath == (Ptr) NULL )
  423.         pstrcpy((Ptr) LcFolderPath,PEMPTY) ;
  424.     else {
  425.         pstrcpy((Ptr) LcFolderPath,TheFolderPath) ;
  426.  
  427.         if ( (PSTRLASTCHAR(TheFolderPath) != PSTRLASTCHAR(PDELIMITER)) )
  428.             pstrcat((Ptr) LcFolderPath,PDELIMITER) ;
  429.     }
  430.  
  431.     if ( TheFileList == (Ptr) NULL )
  432.         pstrcpy((Ptr) LcFileList,PEMPTY) ;
  433.     else
  434.         pstrcpy((Ptr) LcFileList,TheFileList)    ;
  435.  
  436.     LcFilePtr = (Ptr) LcFileList            ;
  437.     PtoCstr((unsigned char *) LcFilePtr)    ;
  438.  
  439.     for ( LcCount = 1 ; ; LcCount++ ) {
  440.         pstrcpy((Ptr) LcFullPathName,(Ptr) LcFolderPath) ;
  441.  
  442.         LcSize = strcspn(LcFilePtr,COMMA) ;
  443.  
  444.         if ( (Size) *(LcFullPathName) + LcSize > 255 )
  445.             return(bdNamErr) ;
  446.  
  447.         BlockMove(
  448.             LcFilePtr,
  449.             (Ptr) &LcFullPathName[*(LcFullPathName)+1],
  450.             LcSize);
  451.  
  452.         *(LcFullPathName) += (char) LcSize ;
  453.  
  454.         itsError = EntityPathToAlias(
  455.             (Ptr) LcFullPathName,typeFILE,&LcFileAlias) ;
  456.         RETN_IF_ERR(itsError)                            ;
  457.     
  458.         HLock((Handle) LcFileAlias) ;
  459.     
  460.         itsError = AEPutPtr(
  461.             &LcAEDescList,
  462.             LcCount,
  463.             typeAlias,
  464.             (Ptr) *LcFileAlias,
  465.             (**LcFileAlias).aliasSize)    ;
  466.     
  467.         HUnlock((Handle) LcFileAlias)        ;
  468.         DisposHandle((Handle) LcFileAlias)    ;
  469.  
  470.         LcFilePtr = &LcFilePtr[LcSize] ;
  471.  
  472.         if ( *LcFilePtr == (char) NULL )
  473.             break ;
  474.  
  475.         LcFilePtr++ ;    // skip the ',' character
  476.     }
  477.  
  478.     MyHLock((Handle) this,&LcChar)    ;
  479.  
  480.     itsError = AEPutParamDesc(
  481.         &itsEvent,
  482.         keySelection,
  483.         &LcAEDescList)        ;
  484.  
  485.     MyHUnlock((Handle) this,LcChar)    ;
  486.  
  487.     for ( ; LcCount > 0 ; LcCount-- ) {
  488.         (void) AEDeleteItem(&LcAEDescList,LcCount) ;
  489.     }
  490.  
  491.     (void) AEDisposeDesc(&LcAEDescList)    ;
  492.  
  493.     return(itsError) ;
  494. }
  495.  
  496.  
  497. OSErr CGenericAE::SendAE(
  498.     AESendMode        TheAESendMode)
  499. {
  500.     char    LcChar         ;
  501.  
  502.     if ( !fEventIsValid )
  503.         return(itsError = errAENotAEDesc) ;
  504.  
  505.     if ( fReplyIsValid )
  506.         (void) AEDisposeDesc(&itsReply)    ;
  507.  
  508.     MyHLock((Handle) this,&LcChar) ;
  509.  
  510.     itsError = AESend(
  511.         &itsEvent,
  512.         &itsReply,
  513.         TheAESendMode,
  514.         kAENormalPriority,
  515.         kAEDefaultTimeout,
  516.         (IdleProcPtr) NULL,
  517.         (EventFilterProcPtr) NULL) ;
  518.  
  519.     MyHUnlock((Handle) this,LcChar) ;
  520.     RETN_IF_ERR(itsError)            ;
  521.  
  522.     fReplyIsValid = TRUE        ;
  523.     return(itsError = noErr)    ;
  524. }
  525.  
  526.  
  527. OSErr CGenericAE::SendAEWithoutReply(void)
  528. {
  529.     return(SendAE(kAENoReply)) ;
  530. }
  531.  
  532.  
  533. OSErr CGenericAE::SendAEWithReply(void)
  534. {
  535.     return(SendAE(kAEWaitReply)) ;
  536. }
  537.  
  538.  
  539. Boolean CGenericAE::GetEvent(
  540.     AppleEventPtr    TheAppleEventPtr)
  541. {
  542.     if ( fEventIsValid ) {
  543.         *TheAppleEventPtr = itsEvent    ;
  544.         return(TRUE)                    ;
  545.     }
  546.  
  547.     return(FALSE) ;
  548. }
  549.  
  550.  
  551. Boolean CGenericAE::GetReply(
  552.     AppleEventPtr    TheAppleEventPtr)
  553. {
  554.     if ( fReplyIsValid ) {
  555.         *TheAppleEventPtr = itsReply    ;
  556.         return(TRUE)                    ;
  557.     }
  558.  
  559.     return(FALSE) ;
  560. }
  561.  
  562.  
  563.