home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / beos / PPBeDevKit.ZIP / PLAYERPR.TAR / PlayerPRO / Source / Mac-PlugImport.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-12-26  |  15.4 KB  |  624 lines
  1. /********************                        ***********************/
  2. //
  3. //    Player PRO 5.0 - DRIVER SOURCE CODE -
  4. //
  5. //    Library Version 5.0
  6. //
  7. //    To use with MAD Library for Mac: Symantec, CodeWarrior and MPW
  8. //
  9. //    Antoine ROSSET
  10. //    16 Tranchees
  11. //    1206 GENEVA
  12. //    SWITZERLAND
  13. //
  14. //    COPYRIGHT ANTOINE ROSSET 1996, 1997, 1998
  15. //
  16. //    Thank you for your interest in PlayerPRO !
  17. //
  18. //    FAX:                (+41 22) 346 11 97
  19. //    PHONE:             (+41 79) 203 74 62
  20. //    Internet:     RossetAntoine@bluewin.ch
  21. //
  22. /********************                        ***********************/
  23.  
  24. #include "mixedmode.h"
  25.  
  26. #include "RDriver.h"
  27. #include "RDriverInt.h"
  28. #include "Aliases.h"
  29. #include "FileUtils.h"
  30. #include "Files.h"
  31. #include <string.h>
  32.  
  33. #define MAXPLUG    40
  34. #define RSRCNAME "\pRsrc Plug Sys##"
  35.  
  36. void pStrCpy( unsigned char *s1, unsigned char *s2)
  37. {
  38.     register short len, i;
  39.     
  40.     if (*s2 <= 220) 
  41.     {
  42.         len = *s2;
  43.         for ( i = 0; i <= len; i++)
  44.         {
  45.             s1[ i] = s2[ i];
  46.         }
  47.     }
  48.     else MyDebugStr( __LINE__, __FILE__, "String to biiig !");
  49. }
  50.  
  51. Handle MADGet1Resource( OSType type, short id, MADLibrary* init)
  52. {
  53.     if( init->sysMemory)
  54.     {
  55.         Handle    tH, dH;
  56.         
  57.         tH = Get1Resource( type, id);
  58.         if( tH == 0L) return 0L;
  59.         
  60.         DetachResource( tH);
  61.         HNoPurge( tH);
  62.         
  63.         dH = NewHandleSys( GetHandleSize( tH));
  64.         if( dH == 0L) MyDebugStr( __LINE__, __FILE__, "");
  65.         if( MemError() != noErr) MyDebugStr( __LINE__, __FILE__, "");
  66.         
  67.         HLock( dH);
  68.         HLock( tH);
  69.         
  70.         BlockMove( *tH, *dH, GetHandleSize( tH));
  71.         
  72.         HUnlock( dH);
  73.         HUnlock( tH);
  74.         
  75.         DisposeHandle( tH);
  76.         tH = 0L;
  77.         
  78.         return dH;
  79.     }
  80.     else
  81.     {
  82.         Handle dH = Get1Resource( type, id);
  83.         if( dH == 0L) return 0L;
  84.         
  85.         DetachResource( dH);
  86.         HNoPurge( dH);
  87.         
  88.         return dH;
  89.     }
  90. }
  91.  
  92. typedef OSErr (*MyProcPtr) ( OSType, char*, MADMusic*, PPInfoRec*, MADDriverSettings *);
  93.  
  94. OSErr CallImportPlug(         MADLibrary        *inMADDriver,
  95.                                                     short                    PlugNo,            // CODE du plug
  96.                                                     OSType                order,
  97.                                                     char                    *AlienFile,
  98.                                                     MADMusic            *theNewMAD,
  99.                                                     PPInfoRec            *info)
  100. {
  101. OSErr                            myErr;
  102. short                            fileID;
  103. UniversalProcPtr     thecall;
  104. MADDriverSettings driverSettings;
  105.  
  106.     driverSettings.sysMemory = false;
  107.  
  108.     if( inMADDriver->ThePlug[ PlugNo].IOPlug == 0L) return -1;
  109.     HLock( inMADDriver->ThePlug[ PlugNo].IOPlug);
  110.     if( *inMADDriver->ThePlug[ PlugNo].IOPlug == 0L) return -1;
  111.     
  112.     if( !EqualString( RSRCNAME, inMADDriver->ThePlug[ PlugNo].file.name, false, false))
  113.     {
  114.         fileID = FSpOpenResFile( &inMADDriver->ThePlug[ PlugNo].file, fsCurPerm);
  115.         UseResFile( fileID);
  116.     }
  117.     
  118.     #define         MyCallMode ( kCStackBased|\
  119.                             RESULT_SIZE( SIZE_CODE( sizeof(OSErr) ))|\
  120.                             STACK_ROUTINE_PARAMETER( 1, SIZE_CODE( sizeof( OSType)))|\
  121.                             STACK_ROUTINE_PARAMETER( 2, SIZE_CODE( sizeof( char*)))|\
  122.                             STACK_ROUTINE_PARAMETER( 3, SIZE_CODE( sizeof( MADMusic*)))|\
  123.                             STACK_ROUTINE_PARAMETER( 4, SIZE_CODE( sizeof( PPInfoRec*)))|\
  124.                             STACK_ROUTINE_PARAMETER( 5, SIZE_CODE( sizeof( MADDriverSettings*))))
  125.     
  126.  
  127.     #if defined(powerc) || defined (__powerc)
  128.     if( inMADDriver->ThePlug[ PlugNo].hasPPCCode)
  129.     {
  130.         thecall = (UniversalProcPtr) *inMADDriver->ThePlug[ PlugNo].IOPlug;
  131.         myErr = CallUniversalProc( thecall, MyCallMode, order, AlienFile, theNewMAD, info, &driverSettings);
  132.     }
  133.     else
  134.     {
  135.         thecall = NewRoutineDescriptor( (ProcPtr) *inMADDriver->ThePlug[ PlugNo].IOPlug, MyCallMode, kM68kISA);
  136.         myErr = CallUniversalProc( thecall, MyCallMode, order, AlienFile, theNewMAD, info, &driverSettings);
  137.         DisposeRoutineDescriptor( thecall);
  138.     }
  139.     #else
  140.         myErr = (* (MyProcPtr) (*inMADDriver->ThePlug[ PlugNo].IOPlug)) ( order, AlienFile, theNewMAD, info, &driverSettings);
  141.     #endif
  142.  
  143. //myErr = TESTmain( order, AlienFile, theNewMAD, info, &driverSettings);
  144.     
  145.     HUnlock( inMADDriver->ThePlug[ PlugNo].IOPlug);
  146.     
  147.     if( !EqualString( RSRCNAME, inMADDriver->ThePlug[ PlugNo].file.name, false, false))
  148.         CloseResFile( fileID);    
  149.     
  150. //    theNewMAD->currentDriver = 0L;
  151.     
  152.     return( myErr);
  153. }
  154.  
  155. OSErr    PPTestFile( MADLibrary        *inMADDriver, char    *kindFile, char    *AlienFile)
  156. {
  157.     short                i;
  158.     MADMusic        aMAD;
  159.     PPInfoRec        InfoRec;
  160.     
  161.     for( i = 0; i < inMADDriver->TotalPlug; i++)
  162.     {
  163.         if( !MADstrcmp( kindFile, inMADDriver->ThePlug[ i].type))
  164.         {
  165.             return( CallImportPlug( inMADDriver, i, 'TEST', AlienFile, &aMAD, &InfoRec));
  166.         }
  167.     }
  168.     return MADCannotFindPlug;
  169. }
  170.  
  171. OSErr PPMADInfoFile( char    *AlienFile, PPInfoRec    *InfoRec)
  172. {
  173.     MADSpec        *theMAD;
  174.     long            fileSize;
  175.     short            fileID;
  176.     
  177.         theMAD = (MADSpec*) NewPtr( sizeof( MADSpec) + 200L);
  178.         
  179.         fileID = iFileOpen( AlienFile);
  180.         if( !fileID)
  181.         {
  182.             DisposePtr( (Ptr) theMAD);
  183.             return -1;
  184.         }
  185.         fileSize = iGetEOF( fileID);
  186.         
  187.         iRead( sizeof( MADSpec), (Ptr) theMAD, fileID);
  188.         iClose( fileID);
  189.         
  190.         strcpy( InfoRec->internalFileName, theMAD->name);
  191.         
  192.         InfoRec->totalPatterns = theMAD->numPat;
  193.         InfoRec->partitionLength = theMAD->numPointers;
  194.         InfoRec->totalTracks = theMAD->numChn;
  195.         InfoRec->signature = 'MADI';
  196.         strcpy( InfoRec->formatDescription, "MADI");
  197.         InfoRec->totalInstruments = theMAD->numInstru;
  198.         InfoRec->fileSize = fileSize;
  199.         
  200.         DisposePtr( (Ptr) theMAD);    
  201.         theMAD = 0L;
  202.         
  203.         return noErr;
  204. }
  205.  
  206. OSErr    PPInfoFile( MADLibrary *inMADDriver, char    *kindFile, char    *AlienFile, PPInfoRec    *InfoRec)
  207. {
  208.     short            i;
  209.     MADMusic    aMAD;
  210.     
  211.     if( !MADstrcmp( kindFile, "MADI"))
  212.     {
  213.         PPMADInfoFile( AlienFile, InfoRec);
  214.         
  215.         return noErr;
  216.     }
  217.     
  218.     for( i = 0; i < inMADDriver->TotalPlug; i++)
  219.     {
  220.         if( !MADstrcmp( kindFile, inMADDriver->ThePlug[ i].type))
  221.         {
  222.             return( CallImportPlug( inMADDriver, i, 'INFO', AlienFile, &aMAD, InfoRec));
  223.         }
  224.     }
  225.     return MADCannotFindPlug;
  226. }
  227.  
  228. OSErr    PPExportFile( MADLibrary *inMADDriver, char    *kindFile, char    *AlienFile, MADMusic    *theNewMAD)
  229. {
  230.     short        i;
  231.     PPInfoRec    InfoRec;
  232.     
  233.     for( i = 0; i < inMADDriver->TotalPlug; i++)
  234.     {
  235.         if( !MADstrcmp( kindFile, inMADDriver->ThePlug[ i].type))
  236.         {
  237.             return( CallImportPlug( inMADDriver, i, 'EXPL', AlienFile, theNewMAD, &InfoRec));
  238.         }
  239.     }
  240.     return MADCannotFindPlug;
  241. }
  242.  
  243. OSErr    PPImportFile( MADLibrary *inMADDriver, char    *kindFile, char *AlienFile, MADMusic    **theNewMAD)
  244. {
  245.     short        i;
  246.     PPInfoRec    InfoRec;
  247.     
  248.     for( i = 0; i < inMADDriver->TotalPlug; i++)
  249.     {
  250.         if( !MADstrcmp( kindFile, inMADDriver->ThePlug[ i].type))
  251.         {
  252.             *theNewMAD = (MADMusic*) MADNewPtrClear( sizeof( MADMusic), inMADDriver);
  253.             if( !*theNewMAD) return -1L;
  254.             
  255.             return( CallImportPlug( inMADDriver, i, 'IMPL', AlienFile, *theNewMAD, &InfoRec));
  256.         }
  257.     }
  258.     return MADCannotFindPlug;
  259. }
  260.  
  261. OSErr CheckMADFile( Ptr name)
  262. {
  263.     UNFILE            refNum;
  264.     char                charl[ 10];
  265.     OSErr                err;
  266.     
  267.     refNum = iFileOpen( name);
  268.     if( !refNum) return -1;
  269.     else
  270.     {
  271.         iRead( 10, charl, refNum);
  272.         
  273.         if( charl[ 0] == 'M' &&                            // MADI
  274.                 charl[ 1] == 'A' &&
  275.                 charl[ 2] == 'D' &&
  276.                 charl[ 3] == 'I') err = noErr;
  277.         else err = -1;
  278.         
  279.         iClose( refNum);
  280.     }
  281.     
  282.     return err;
  283. }
  284.  
  285. OSErr    PPIdentifyFile( MADLibrary *inMADDriver, char *type, char *AlienFile)
  286. {
  287.     UNFILE            refNum;
  288.     short                i;
  289.     PPInfoRec        InfoRec;
  290.     OSErr                iErr = noErr;
  291.     
  292.     MADstrcpy( type, "!!!!");
  293.     
  294.     // Check if we have access to this file
  295.     refNum = iFileOpen( AlienFile);
  296.     if( !refNum) return -1;
  297.     else
  298.     {
  299.         if( iGetEOF( refNum) < 100) iErr = -36;
  300.         iClose( refNum);
  301.         if( iErr) return iErr;
  302.     }
  303.     
  304.     // Is it a MAD file?
  305.     iErr = CheckMADFile( AlienFile);
  306.     if( iErr == noErr)
  307.     {
  308.         MADstrcpy( type, "MADI");
  309.         return noErr;
  310.     }
  311.     
  312.     for( i = 0; i < inMADDriver->TotalPlug; i++)
  313.     {
  314.         if( CallImportPlug( inMADDriver, i, 'TEST', AlienFile, 0L, &InfoRec) == noErr)
  315.         {
  316.             MADstrcpy( type, inMADDriver->ThePlug[ i].type);
  317.             
  318.             return noErr;
  319.         }
  320.     }
  321.     
  322.     MADstrcpy( type, "!!!!");
  323.     return MADCannotFindPlug;
  324. }
  325.  
  326. OSType    GetPPPlugType( MADLibrary *inMADDriver, short ID, OSType mode)
  327. {
  328.     short    i, x;
  329.  
  330.     if( ID >= inMADDriver->TotalPlug) MyDebugStr( __LINE__, __FILE__, "PP-Plug ERROR. ");
  331.  
  332.     for( i = 0, x = 0; i < inMADDriver->TotalPlug; i++)
  333.     {
  334.         if( inMADDriver->ThePlug[ i].mode == mode || inMADDriver->ThePlug[ i].mode == 'EXIM')
  335.         {
  336.             if( ID == x)
  337.             {
  338.                 short     xx;
  339.                 OSType    type;
  340.                 
  341.                 xx = strlen( inMADDriver->ThePlug[ i].type);
  342.                 if( xx > 4) xx = 4;
  343.                 type = '    ';
  344.                 BlockMove( inMADDriver->ThePlug[ i].type, &type, xx);
  345.  
  346.                 return type;
  347.             }
  348.             x++;
  349.         }
  350.     }
  351.  
  352.     MyDebugStr( __LINE__, __FILE__, "PP-Plug ERROR II.");
  353.     
  354.     return noErr;
  355. }
  356.  
  357. Boolean    MADPlugAvailable( MADLibrary        *inMADDriver, char    *kindFile)
  358. {
  359.     short        i;
  360.  
  361.     if( !MADstrcmp( kindFile, "MADI")) return true;
  362.     
  363.     for( i = 0; i < inMADDriver->TotalPlug; i++)
  364.     {
  365.         if( !MADstrcmp( kindFile, inMADDriver->ThePlug[ i].type)) return true;
  366.     }
  367.     return false;
  368. }
  369.  
  370. void LoadImportPLUG( MADLibrary        *inMADDriver, short    No, FSSpec    *theSpec)
  371. {
  372. Handle        theRes;
  373. short        fileID;
  374. Str255        tStr;
  375.  
  376.     inMADDriver->ThePlug[ No].file = *theSpec;
  377.     
  378.     fileID = FSpOpenResFile( theSpec, fsCurPerm);
  379.     
  380.     /** CODE du Plug-in **/
  381.     
  382.     #if defined(powerc) || defined (__powerc)
  383.         theRes = MADGet1Resource('PPCC', 1000, inMADDriver);
  384.         if( theRes != 0L)
  385.         {
  386.             inMADDriver->ThePlug[ No].hasPPCCode = true;
  387.         }
  388.         else
  389.         {
  390.             inMADDriver->ThePlug[ No].hasPPCCode = false;
  391.             theRes = MADGet1Resource('CODE', 1000, inMADDriver);
  392.         }
  393.         if( theRes == 0L) MyDebugStr( __LINE__, __FILE__, "Err Plug");
  394.         if( *theRes == 0L) MyDebugStr( __LINE__, __FILE__, "Err Plug Rsrc Second Level");
  395.         
  396.         inMADDriver->ThePlug[ No].IOPlug        = theRes;
  397.     #else
  398.         theRes = MADGet1Resource('CODE', 1000, inMADDriver);
  399.         if( theRes == 0L) MyDebugStr( __LINE__, __FILE__, "Err Plug");
  400.         if( *theRes == 0L) MyDebugStr( __LINE__, __FILE__, "Err Plug Rsrc Second Level");
  401.         
  402.         inMADDriver->ThePlug[ No].IOPlug        = theRes;
  403.     #endif
  404.     
  405.     GetIndString( tStr, 1000, 1);
  406.     BlockMove( tStr + 1, &inMADDriver->ThePlug[ No].type, 4);
  407.     inMADDriver->ThePlug[ No].type[ 4] = 0;
  408.     
  409.     GetIndString( tStr, 1000, 2);
  410.     BlockMove( tStr + 1, &inMADDriver->ThePlug[ No].mode, 4);
  411.     
  412.     GetIndString( inMADDriver->ThePlug[ No].MenuName, 1000, 3);
  413.     GetIndString( inMADDriver->ThePlug[ No].AuthorString, 1000, 4);
  414.     
  415.     CloseResFile( fileID);
  416. }
  417.  
  418. void NScanDirImportPlug( MADLibrary        *inMADDriver, long dirID, short VRefNum, Str255    Fname)
  419. {
  420.         CInfoPBRec        info;
  421.         Str255            tempStr;
  422.         short            i;
  423.         Boolean            targetIsFolder, wasAliased;
  424.         FSSpec            theSpec;
  425.         FInfo            fndrInfo;
  426.  
  427.     info.hFileInfo.ioNamePtr = tempStr;
  428.     info.hFileInfo.ioVRefNum = VRefNum;
  429.     
  430.     for (i = 1; true; i ++)
  431.     {
  432.         info.hFileInfo.ioDirID            = dirID;
  433.         info.hFileInfo.ioFDirIndex        = i;
  434.         
  435.         if (PBGetCatInfoSync( &info) != noErr) break;
  436.         
  437.         FSMakeFSSpec( info.hFileInfo.ioVRefNum, dirID, info.hFileInfo.ioNamePtr, &theSpec);
  438.         ResolveAliasFile( &theSpec, true, &targetIsFolder, &wasAliased);
  439.         FSpGetFInfo( &theSpec, &fndrInfo);
  440.         
  441.         if( targetIsFolder)            //if((info.hFileInfo.ioFlAttrib & 16))
  442.         {
  443.             if( Fname[ 0] > 0)
  444.             {
  445.                 if( EqualString( info.hFileInfo.ioNamePtr, Fname, false, false))    // == true ||
  446.                 //    EqualString( theSpec.name, Fname, false, false) == true)
  447.                 {
  448.                     CInfoPBRec        ci;
  449.  
  450.                     ci.hFileInfo.ioNamePtr         = theSpec.name;
  451.                     ci.hFileInfo.ioVRefNum         = theSpec.vRefNum;
  452.                     ci.hFileInfo.ioDirID          = theSpec.parID;
  453.                     ci.hFileInfo.ioFDirIndex    = 0;
  454.                     
  455.                     PBGetCatInfoSync( &ci);
  456.                     
  457.                     NScanDirImportPlug( inMADDriver, ci.hFileInfo.ioDirID, ci.hFileInfo.ioVRefNum, Fname);
  458.                 }
  459.             }
  460.         }
  461.         else if( fndrInfo.fdType == 'IMPL')            //if( info.hFileInfo.ioFlFndrInfo.fdType == 'IMPL')
  462.         {
  463.         //    HGetVol( 0L, &vRefNum, &dirIDCopy);
  464.         ////    
  465.         //    iErr = HSetVol( 0L, theSpec.vRefNum, theSpec.parID);
  466.             
  467.             if( inMADDriver->TotalPlug < MAXPLUG)
  468.             {
  469.                 LoadImportPLUG( inMADDriver, inMADDriver->TotalPlug, &theSpec);
  470.                 inMADDriver->TotalPlug++;
  471.             }
  472.             
  473.         //    iErr = HSetVol( 0L, vRefNum, dirIDCopy);
  474.         //    if( iErr != noErr) MyDebugStr( __LINE__, __FILE__, "HSetVol error...");
  475.         }
  476.     }
  477. }
  478.  
  479. /*void InitImportMenu(void)
  480. {
  481. short    i;
  482.  
  483.     ImportMenu    = GetMenu( 138);
  484.     ExportMenu    = GetMenu( 139);
  485.  
  486.  
  487.     for( i = 0; i < inMADDriver->TotalPlug; i++)
  488.     {
  489.         switch( inMADDriver->ThePlug[ i].mode)
  490.         {
  491.             case 'EXIM':
  492.                 AppendMenu( ImportMenu, inMADDriver->ThePlug[ i].MenuName);
  493.                 AppendMenu( ExportMenu, inMADDriver->ThePlug[ i].MenuName);
  494.             break;
  495.             
  496.             case 'EXPL':
  497.                 AppendMenu( ExportMenu, inMADDriver->ThePlug[ i].MenuName);
  498.             break;
  499.             
  500.             case 'IMPL':
  501.                 AppendMenu( ImportMenu, inMADDriver->ThePlug[ i].MenuName);
  502.             break;
  503.         }
  504.     }
  505.  
  506.     InsertMenu( ImportMenu, hierMenu);
  507.     InsertMenu( ExportMenu, hierMenu);
  508. }*/
  509.  
  510. void NScanResource( MADLibrary *inMADDriver)
  511. {
  512.     short    i;
  513.     
  514.     #define BASERES    5000
  515.     
  516.     for( i = 0; i < MAXPLUG; i++)
  517.     {
  518.         Boolean ResourceOK;
  519.         Handle    aRes, bRes;
  520.         
  521.         ResourceOK = true;
  522.         
  523.         aRes = MADGet1Resource( 'CODE', BASERES + i, inMADDriver);
  524.         if( aRes == 0L) ResourceOK = false;
  525.         else
  526.         {
  527.             DisposeHandle( aRes);
  528.             aRes = 0L;
  529.         }
  530.         
  531.         bRes = MADGet1Resource( 'STR#', BASERES + i, inMADDriver);
  532.         if( bRes == 0L) ResourceOK = false;
  533.         else
  534.         {
  535.             DisposeHandle( bRes);
  536.             bRes = 0L;
  537.         }
  538.         
  539.         if( inMADDriver->TotalPlug < MAXPLUG && ResourceOK == true)
  540.         {
  541.             short        No = inMADDriver->TotalPlug;
  542.             Handle        theRes;
  543.             Str255        tStr;
  544.             
  545.         //    theName = LMGetCurApName();
  546.             
  547.             HGetVol( 0L, &inMADDriver->ThePlug[ No].file.vRefNum, &inMADDriver->ThePlug[ No].file.parID);
  548.             pStrCpy( inMADDriver->ThePlug[ No].file.name, RSRCNAME);
  549.             
  550.             /** CODE du Plug-in **/
  551.             
  552.             #if defined(powerc) || defined (__powerc)
  553.                 theRes = MADGet1Resource('PPCC', BASERES+i, inMADDriver);
  554.                 if( theRes != 0L)
  555.                 {
  556.                     inMADDriver->ThePlug[ No].hasPPCCode = true;
  557.                 }
  558.                 else
  559.                 {
  560.                     inMADDriver->ThePlug[ No].hasPPCCode = false;
  561.                     theRes = MADGet1Resource('CODE', BASERES+i, inMADDriver);
  562.                 }
  563.                 if( theRes == 0L) MyDebugStr( __LINE__, __FILE__, "Err Plug Rsrc");
  564.                 if( *theRes == 0L) MyDebugStr( __LINE__, __FILE__, "Err Plug Rsrc Second Level");
  565.                 
  566.                 inMADDriver->ThePlug[ No].IOPlug        = theRes;
  567.             #else
  568.                 theRes = MADGet1Resource('CODE', BASERES+i, inMADDriver);
  569.                 if( theRes == 0L) MyDebugStr( __LINE__, __FILE__, "Err Plug Rsrc");
  570.                 if( *theRes == 0L) MyDebugStr( __LINE__, __FILE__, "Err Plug Rsrc Second Level");
  571.                 inMADDriver->ThePlug[ No].IOPlug        = theRes;
  572.             #endif
  573.             
  574.             GetIndString( tStr, BASERES+i, 1);
  575.             BlockMove( tStr + 1, &inMADDriver->ThePlug[ No].type, 4);
  576.             inMADDriver->ThePlug[ No].type[ 4] = 0;
  577.             
  578.             GetIndString( tStr, BASERES+i, 2);
  579.             BlockMove( tStr + 1, &inMADDriver->ThePlug[ No].mode, 4);
  580.             
  581.             GetIndString( inMADDriver->ThePlug[ No].MenuName, BASERES+i, 3);
  582.             GetIndString( inMADDriver->ThePlug[ No].AuthorString, BASERES+i, 4);
  583.             
  584.             inMADDriver->TotalPlug++;
  585.         }
  586.     }
  587. }
  588.  
  589. void MInitImportPlug( MADLibrary *inMADDriver, Ptr PlugsFolderName)
  590. {
  591.     short        vRefNum;
  592.     long        dirID;
  593.     
  594.     HGetVol( 0L, &vRefNum, &dirID);
  595.     
  596.     inMADDriver->ThePlug = (PlugInfo*) MADNewPtr( MAXPLUG * sizeof( PlugInfo), inMADDriver);
  597.     inMADDriver->TotalPlug = 0;
  598.     
  599.     if( PlugsFolderName != 0L)
  600.     {
  601.         c2pstr( PlugsFolderName);
  602.         NScanDirImportPlug( inMADDriver, dirID, vRefNum, (unsigned char*) PlugsFolderName);
  603.         p2cstr( (unsigned char*) PlugsFolderName);
  604.     }
  605.     
  606.     HSetVol( 0L, vRefNum, dirID);
  607.     
  608.     NScanResource( inMADDriver);
  609. }
  610.  
  611. void CloseImportPlug( MADLibrary        *inMADDriver)
  612. {
  613. short    i;
  614.  
  615.     for( i = 0; i < inMADDriver->TotalPlug; i++)
  616.     {
  617.         if( inMADDriver->ThePlug[ i].IOPlug != 0L)
  618.             DisposeHandle( inMADDriver->ThePlug[ i].IOPlug);
  619.         
  620.         inMADDriver->ThePlug[ i].IOPlug = 0L;
  621.     }
  622.  
  623.     DisposePtr( (Ptr) inMADDriver->ThePlug);        inMADDriver->ThePlug = 0L;
  624. }