home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / source / gblanker36_src.lha / GSource.lha / GSource / module.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-31  |  6.3 KB  |  260 lines
  1. /*
  2.  *  Copyright (c) 1994 Michael D. Bayne.
  3.  *  All rights reserved.
  4.  *
  5.  *  Please see the documentation accompanying the distribution for distribution
  6.  *  and disclaimer information.
  7.  */
  8.  
  9. #include <exec/memory.h>
  10. #include <dos/dostags.h>
  11. #include <strings.h>
  12.  
  13. #include "includes.h"
  14. #include "libraries.h"
  15. #include "protos/protos.h"
  16.  
  17. struct Screen *ServerScr;
  18. struct Window *Wnd;
  19. LONG NumBlankEntries;
  20.  
  21. VOID ToggleModuleDisabled( BlankerPrefs *Prefs )
  22. {
  23.     struct FileInfoBlock *Blk;
  24.     BPTR BlankerLock;
  25.     BYTE Path[108];
  26.     
  27.     strcpy( Path, Prefs->bp_Dir );
  28.     AddPart( Path, Prefs->bp_Blanker, 108 );
  29.     
  30.     if( BlankerLock = Lock( Path, ACCESS_READ ))
  31.     {
  32.         if( Blk = AllocDosObject( DOS_FIB, 0L ))
  33.         {
  34.             if( Examine( BlankerLock, Blk ))
  35.             {
  36.                 if( Stricmp( Blk->fib_Comment, "Disabled" ))
  37.                     SetComment( Path, "Disabled" );
  38.                 else
  39.                     SetComment( Path, "" );
  40.             }
  41.             FreeDosObject( DOS_FIB, Blk );
  42.         }
  43.         UnLock( BlankerLock );
  44.     }
  45. }
  46.  
  47. VOID ExecSubProc( STRPTR Command, STRPTR Extension )
  48. {
  49.     BPTR in = Open( "NIL:", MODE_OLDFILE );
  50.     BPTR out = Open( "NIL:", MODE_OLDFILE );
  51.     BYTE Path[216], Target[108];
  52.     
  53.     strcpy( Path, Prefs->bp_Dir );
  54.     AddPart( Path, Command, 216 );
  55.     strcat( Path, " " );
  56.     
  57.     strcpy( Target, Prefs->bp_Dir );
  58.     AddPart( Target, Prefs->bp_Blanker, 108 );
  59.     strcat( Path, Target );
  60.     strcat( Path, Extension );
  61.     
  62.     if( in && out &&( SystemTags( Path, SYS_Asynch, TRUE, SYS_Input, in,
  63.                                  SYS_Output, out, TAG_END ) != -1 ))
  64.         return;
  65.     
  66.     if( in )
  67.         Close( in );
  68.     if( out )
  69.         Close( out );
  70. }    
  71.  
  72. #define SIG_DELAY ( 1L << DelayPort->mp_SigBit )
  73.  
  74. VOID __saveds PingFunc( VOID )
  75. {
  76.     struct MsgPort *ClientPort, *ReplyPort;
  77.     struct Library *SysBase;
  78.     BlankMsg PingMsg;
  79.  
  80.     SysBase = *( struct Library ** )4L;
  81.  
  82.     if( ReplyPort = CreateMsgPort())
  83.     {
  84.         PingMsg.bm_Mess.mn_ReplyPort = ReplyPort;
  85.         PingMsg.bm_Mess.mn_Length = sizeof( BlankMsg );
  86.         PingMsg.bm_Type = BM_PING;
  87.         /* Stealthimania, to alleviate processing at the blanker */
  88.         PingMsg.bm_Mess.mn_Node.ln_Name = ( UBYTE * )( &Blanking );
  89.  
  90.         for( ;; )
  91.         {
  92.             if( SetSignal( 0L, SIGBREAKF_CTRL_C ) & SIGBREAKF_CTRL_C )
  93.                 break;
  94.  
  95.             if( ClientPort = FindPort( "GarshneClient" ))
  96.             {
  97.                 PingMsg.bm_Flags = 0L;
  98.                 PutMsg( ClientPort, ( struct Message * )( &PingMsg ));
  99.                 WaitPort( ReplyPort );
  100.                 GetMsg( ReplyPort );
  101.             }
  102.         }
  103.         DeletePort( ReplyPort );
  104.     }
  105. }
  106.  
  107. VOID InternalBlank( VOID )
  108. {
  109.     if( !ServerScr )
  110.     {
  111.         ServerScr = OpenScreenTags( 0L, SA_DisplayID, getTopScreenMode(),
  112.                                    SA_Depth, 1, SA_Behind, 1, SA_Quiet, TRUE,
  113.                                    TAG_END );
  114.         if( ServerScr )
  115.         {
  116.             Wnd = BlankMousePointer( ServerScr );
  117.             SetRGB4(&( ServerScr->ViewPort ), 0, 0, 0, 0 );
  118.             SetRGB4(&( ServerScr->ViewPort ), 1, 0, 0, 0 );
  119.             ScreenToFront( ServerScr );
  120.             Blanking = TRUE;
  121.         }
  122.     }
  123. }
  124.  
  125. VOID MessageModule( STRPTR PortName, LONG Type )
  126. {
  127.     struct MsgPort *ClientPort;
  128.     BlankMsg *ClientMsg;
  129.     
  130.     if( ClientPort = FindPort( PortName ))
  131.     {
  132.         if( ClientMsg = AllocVec( sizeof( BlankMsg ), MEMF_CLEAR|MEMF_PUBLIC ))
  133.         {
  134.             ClientMsg->bm_Mess.mn_ReplyPort = ServerPort;
  135.             ClientMsg->bm_Mess.mn_Length = sizeof( BlankMsg );
  136.             /* Stealthimania */
  137.             ClientMsg->bm_Mess.mn_Node.ln_Name = ( UBYTE * )( &Blanking );
  138.             ClientMsg->bm_Type = Type;
  139.             PutMsg( ClientPort, ( struct Message * )ClientMsg );
  140.             return;
  141.         }
  142.     }
  143.     
  144.     if( Type == BM_DOBLANK )
  145.         InternalBlank();
  146. }
  147.  
  148. VOID LoadModule( STRPTR Dir, STRPTR Module )
  149. {
  150.     BPTR in = Open( "NIL:", MODE_OLDFILE );
  151.     BPTR out = Open( "NIL:", MODE_OLDFILE );
  152.     BYTE Path[256];
  153.     
  154.     if( !Stricmp( Module, "Random" ))
  155.         Module = RandomModule();
  156.     
  157.     if( !Module )
  158.         return;
  159.     
  160.     strcpy( Path, Dir );
  161.     AddPart( Path, Module, 256 );
  162.     
  163.     if( in && out )
  164.         if( SystemTags( Path, SYS_Asynch, TRUE, SYS_Input, in, SYS_Output, out,
  165.                        TAG_END ) != -1 )
  166.             return;
  167.     
  168.     if( in )
  169.         Close( in );
  170.     if( out )
  171.         Close( out );
  172. }
  173.  
  174. BlankerEntry *NewBlankerEntry( STRPTR Path, STRPTR Name, STRPTR Comment )
  175. {
  176.     BlankerEntry *New = AllocVec( sizeof( BlankerEntry ), MEMF_CLEAR );
  177.     
  178.     if( New )
  179.     {
  180.         strcpy( New->be_Path, Path );
  181.         AddPart( New->be_Path, Name, 128 );
  182.         New->be_Name = FilePart( New->be_Path );
  183.         New->be_Disabled = !Stricmp( Comment, "Disabled" );
  184.         New->be_Node.ln_Name = New->be_Name;
  185.     }
  186.     
  187.     return New;
  188. }
  189.  
  190. LONG FileIsModule( STRPTR Path, STRPTR Name )
  191. {
  192.     if( strstr( Name, ".ifc" ) || strstr( Name, ".txt" ) ||
  193.        strstr( Name, ".prefs" ))
  194.         return FALSE;
  195.     
  196.     if( !Stricmp( Name, "PrefInterp" ))
  197.         return FALSE;
  198.     
  199.     if( !Stricmp( Name, "ShowInfo" ))
  200.         return FALSE;
  201.     
  202.     return TRUE;
  203. }
  204.  
  205. VOID FreeBlankerEntries( struct List *Entries )
  206. {
  207.     BlankerEntry *FreeMe;
  208.     
  209.     if( !Entries )
  210.         return;
  211.     
  212.     while( FreeMe = ( BlankerEntry * )RemHead( Entries ))
  213.         FreeVec( FreeMe );
  214.     
  215.     FreeVec( Entries );
  216. }
  217.  
  218. struct List *LoadBlankerEntries( STRPTR Path )
  219. {
  220.     struct FileInfoBlock *Blk;
  221.     struct List *Entries = 0L;
  222.     BlankerEntry *New;
  223.     BPTR DirLock;
  224.     
  225.     if(!( Entries = AllocVec( sizeof( struct List ), MEMF_CLEAR )))
  226.         return 0L;
  227.     else
  228.         NewList( Entries );
  229.     
  230.     NumBlankEntries = 0;
  231.     
  232.     if( DirLock = Lock( Path, ACCESS_READ ))
  233.     {
  234.         if(( Blk = AllocDosObject( DOS_FIB, 0L ))&&( Examine( DirLock, Blk )))
  235.         {
  236.             while( ExNext( DirLock, Blk ))
  237.             {
  238.                 if(( Blk->fib_FileName )&&
  239.                    ( FileIsModule( Path, Blk->fib_FileName )))
  240.                 {
  241.                     if( New = NewBlankerEntry( Path, Blk->fib_FileName,
  242.                                               Blk->fib_Comment ))
  243.                     {
  244.                         New->be_Node.ln_Pri = 128 - ( New->be_Name[0] - 'a' );
  245.                         Enqueue( Entries, ( struct Node * )New );
  246.                         NumBlankEntries++;
  247.                     }
  248.                 }
  249.             }
  250.             FreeDosObject( DOS_FIB, Blk );
  251.         }
  252.         UnLock( DirLock );
  253.     }
  254.     
  255.     if( New = NewBlankerEntry( ":", "Random", "" ))
  256.         AddTail( Entries, ( struct Node * )New );
  257.     
  258.     return Entries;
  259. }
  260.