home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 019.lha / Aterm / ClockLoader.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-11-10  |  6.2 KB  |  190 lines
  1. /* ClockLoader.c */
  2. /* 
  3.  * StartClock(): - by Jeff Lydiatt, Vancouver, Canada, B.C.
  4.  *
  5.  * Business first... This code is NOT to be used for commercial purposes.
  6.  * You are granted a limited license to distribute it on a not-for-profit
  7.  * basis by any means, including, but not limited to, paper, magnetic media,
  8.  * or telecommunications. We have no objection to its appearance on a 
  9.  * commercial communications network provided it may be obtained for no
  10.  * cost over and above the standard connect time charges.
  11.  *  In addition, we would appreciate it if anyone modifying this code
  12.  * would attempt to get the modifications back to us so that we can
  13.  * keep some semblance of continuity of versions.
  14.  *
  15.  * Jeff Lydiatt
  16.  * Larry Phillips, Compuserve, 76703,4322
  17.  *
  18.  * Code to load AtermClock, send it a wake up message, and the
  19.  * address of the window where the clock/calendar is to be displayed.
  20.  * DeleteClock(): Send message to AtermClock to shut down, then
  21.  *   unload its space.
  22.  *
  23.  *    This module uses the AmigaDos LoadSeg and CreateProc functions to
  24.  * load the clock/calendar, AtermClock, from the current directory and to
  25.  * start it as a separate process.  With the way the parameters are set up,
  26.  * AtermClock thinks it has been loaded by WorkBench and by convention waits
  27.  * for a start up message from WorkBench containing some needed parameters.
  28.  * This part of the AtermClock code is handled by an initialization program
  29.  * provided by Aztec that is called before the "main" subroutine.  The loader
  30.  * program first sends the wakeup call together with the WorkBench parameters
  31.  * that are normally provided by WorkBench.  The loader then sends a message
  32.  * giving AtermClock the address of the display window, and waits for an
  33.  * "OK" reply before returning.
  34.  *
  35.  *   The DeleteClock() subroutine sends a message to request AtermClock to
  36.  * wind up, and waits for a reply.  AtermClock does not check the contents
  37.  * of the message, so it doesn't matter what the message content is.  A
  38.  * second "Wait" is needed to capture the "Reply" from AtermClock for the
  39.  * loader's first wakeup message.  The "Reply" is sent by the Aztec-provided
  40.  * exit() code.  When the "Reply" has been received, DeleteClock()
  41.  * frees any resources opened by the loader and returns. 
  42.  */
  43.  
  44. #include <exec/types.h>
  45. #include <exec/memory.h>
  46. #include <exec/ports.h>
  47. #include <exec/tasks.h>
  48. #include <exec/execbase.h>
  49. #include <intuition/intuition.h>
  50. #include <workbench/startup.h>
  51. #include <functions.h>
  52. #include "Clock.h"
  53. #include "ConsoleIO.h"
  54.  
  55. #define PRIORITY    0
  56. #define STACKSIZE    4096
  57. #define CLOCKNAME    "C:AtermClock"
  58. #define CLOCKNAME2    "AtermClock"
  59. static struct Process *myProcess = NULL;
  60. static struct Process *ClockProc = NULL;
  61. static struct WBStartup *msg = NULL;
  62. static struct ParmMsg *parms = NULL;
  63. static struct Segment *ClockSeg = NULL;
  64. static struct MsgPort *myPort = NULL;    /* Pointer to my private port */
  65. static char *startName = "StartMessage";
  66. static char *parmName  = "Parameter";
  67.  
  68.    /*------------------------------------------------------------*/
  69.    /*        Cleanup: after Clock is stopped             */
  70.    /*------------------------------------------------------------*/
  71.  
  72. static void CleanUp()
  73. {
  74.    if ( ClockSeg != NULL )
  75.       UnLoadSeg( ClockSeg );
  76.    if ( msg != NULL )  { FreeMem( msg, (long)sizeof( struct WBStartup ) );     }
  77.    if ( parms != NULL) { FreeMem( parms, (long)sizeof( struct ParmMsg ) ); }
  78.    if ( myPort != NULL){ DeletePort( myPort ); }
  79.    msg = NULL;
  80.    parms = NULL;
  81.    ClockSeg = NULL;
  82.    myPort = NULL;
  83. }
  84.  
  85.    /*------------------------------------------------------------*/
  86.    /*        StartClock: as a subtask             */
  87.    /*------------------------------------------------------------*/
  88.  
  89. BOOL StartClock( window )
  90. struct Window *window;
  91. {
  92.    register struct WBStartup *wPtr;
  93.    register struct ParmMsg   *pPtr;
  94.  
  95.    /*-------- See if we have enough scratch memory----------*/
  96.  
  97.     myProcess = (struct Process *)FindTask( NULL );
  98.     myPort = CreatePort( "ClockPort", NULL );
  99.     msg = (struct WBStartup *) AllocMem(
  100.           (long)sizeof( struct WBStartup ), (long)(MEMF_CLEAR) );
  101.     parms = (struct ParmMsg *)AllocMem(
  102.         (long)sizeof( struct ParmMsg), (long)(MEMF_CLEAR) );
  103.     if ( myPort == NULL || msg == NULL || parms == NULL )
  104.       {
  105.     PutString( "\x9b33mNOTE: Insufficent memory to run clock!\n\x9bm" );
  106.     CleanUp();
  107.     return FALSE;
  108.       }
  109.     wPtr = msg;
  110.     pPtr = parms;
  111.  
  112.    /*-------- Load the Clock Program --------------*/
  113.  
  114.    ClockSeg = LoadSeg( CLOCKNAME );
  115.    if ( ClockSeg == NULL )
  116.      { ClockSeg = LoadSeg( CLOCKNAME2 );
  117.        if ( ClockSeg == NULL )
  118.          {
  119.        PutString( "\x9b33mNOTE: No Clock... \"" );
  120.        PutString( CLOCKNAME2 );
  121.        PutString( "\" must be in your \"C:\" or current directory.\n\x9bm" );
  122.        CleanUp();
  123.        return FALSE;
  124.          }
  125.      }
  126.  
  127.     /*------Create a Process for the Clock----------*/
  128.  
  129.    ClockProc = CreateProc( CLOCKNAME, (long)(PRIORITY),
  130.         ClockSeg, (long)(STACKSIZE) );
  131.    if ( ClockProc == NULL )
  132.      {
  133.     PutString( "\x9b33mCan't start Clock Process.\n\x9bm" );
  134.     CleanUp();
  135.     return FALSE;
  136.      }
  137.  
  138.     /*------- Wake Up the Process we Created -----*/
  139.  
  140.     wPtr->sm_Message.mn_ReplyPort = myPort;
  141.     wPtr->sm_Message.mn_Length = sizeof( struct WBStartup );
  142.     wPtr->sm_Message.mn_Node.ln_Name = startName;
  143.     wPtr->sm_ArgList = NULL;
  144.     wPtr->sm_ToolWindow = NULL;
  145.     PutMsg( ClockProc, wPtr );
  146.  
  147.     /*------- Now Send the process the address of my window -------*/
  148.  
  149.     pPtr->mm_Message.mn_ReplyPort = myPort;
  150.     pPtr->mm_Message.mn_Length = sizeof( struct ParmMsg  );
  151.     pPtr->mm_Message.mn_Node.ln_Name = parmName;
  152.     pPtr->windowPtr = window;
  153.     PutMsg( ClockProc, pPtr );
  154.  
  155.     /* ... and wait for reply to Parm msg received */
  156.  
  157.     WaitPort( myPort );
  158.     (void) GetMsg( myPort );
  159.  
  160.     return TRUE;
  161. }
  162.  
  163.    /*------------------------------------------------------------*/
  164.    /*    Delete the Clock Task.                     */
  165.    /*------------------------------------------------------------*/
  166.  
  167. void DeleteClock()
  168. {
  169.  
  170.    if ( ClockProc != NULL )
  171.       {
  172.     if ( parms != NULL )
  173.        {
  174.         /* Signal the Clock to Stop */
  175.         PutMsg( ClockProc, parms );
  176.         WaitPort( myPort );
  177.         (void) GetMsg( myPort );
  178.         }
  179.  
  180.     if ( msg != NULL )
  181.         {
  182.         /* Wait for the Wakeup Message Reply */ 
  183.         WaitPort( myPort );
  184.         (void) GetMsg( myPort );
  185.         }
  186.      }
  187.    ClockProc = NULL;
  188.    CleanUp();
  189. }
  190.