home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / mac / source / telex1.sit / Telexƒ / TelexDA.c < prev    next >
C/C++ Source or Header  |  1991-05-04  |  36KB  |  907 lines
  1.                             /* ====================================== *\
  2.                             ** ==         AppleTalk  Teletype      == **
  3.                             ** ==     Client DA (Message Sender)   == **
  4.               ** == Copyright ⌐ Gamma Software, 1990 == **
  5.               ** ==           Think C version        == **
  6.                             \* ====================================== */
  7.  
  8.  
  9. /* == standard definitions === */
  10. typedef int           boolean;
  11. typedef unsigned char unchar;
  12.  
  13. #define NIL               0
  14. #define FALSE             0
  15. #define TRUE              1
  16.  
  17. #define ETX            0x03
  18. #define ScrSize          16
  19.  
  20. #include <AppleTalk.h>
  21. #include <nAppleTalk.h>
  22.  
  23. /*
  24.  * AppleTalk standard definitions
  25.  */
  26. #define  HomeID        0xC120                 /* Chooser("System") Name        */ 
  27. #define zipSocket          6                  /* ZIP socket number in Router   */
  28.  
  29. #define  ATtype        "\pTelex"              /* Telex Listener AT type        */
  30.  
  31. /*
  32.  * AppleTalk IO parameters
  33.  */
  34.           /* SendRequest (i.e. send message) */
  35. #define    ReqTimeOut     2                   /* Timeout for MSG SendRequest   */
  36. #define    ReqRepeat      3                   /* Number of rep while sending   */
  37.  
  38.           /* NBPLookup (i.e. look for listeners in the zone) */
  39. #define MaxToGet         50                   /* Max Number of Listeners       */
  40. #define AskTimeOut    (5*8)                   /* Time-out for NBP-operations   */
  41. #define AskPolling  (30*60)                   /* Max time to wait before drop  */
  42.  
  43.           /* GetZoneList (i.e. look for all zones names) */
  44. #define ZipTimeOut    (5*8)                   /* Time-out for GetZonesList     */
  45. #define ZipRepeat         1                   /* Number of retries for -- " -- */
  46. #define ZipPolling (120*60)                   /* Period of GetZoneList polling */
  47.  
  48.  
  49. #define dialogID  0                           /* rsrc ID (owned): DA DLOG      */
  50. #define aboutID   1                           /* rsrc ID (owned): About Alert  */
  51.  
  52.  
  53. /*
  54.  * Codes of Error Messages:
  55.  * O.K., Listener is died, IO error, Listener buffer is full, System Error
  56.  */
  57. enum {SendOK=0, SendNoAb, SendIOerr, SendAbFull, SendSysErr};
  58.  
  59. /*
  60.  * Items in the Telex DA dialog box
  61.  */
  62. enum {itSend = 1, itMessage, itList, itAbout, itError, itZones};
  63.  
  64.  
  65.   short          theResID;                    /* DA rsrc ID (add to owned IDs) */
  66.  
  67.   DialogPtr      theDialog = NIL;             /* DA dialog                     */
  68.   ControlHandle  sendButton;                  /* "Send" Button, obviously      */
  69.  
  70.   boolean        modNames;                    /* namesList selection modified  */
  71.   boolean        modZones;                    /* zonesList selection modified  */
  72.  
  73.   ListHandle     namesList;                   /* listeners list: names and addr*/
  74.   ListHandle     zonesList;                   /* zones     list: names and nums*/
  75.   short          theBridge;
  76.   MPPParamBlock  askRecord;                   /* ParameterBlock for NPBLookup  */
  77.   ATPParamBlock  zipRecord;                   /* ParameterBlock for ZIPGetZone */
  78.  
  79.   short          zipIndex;                    /* index for GetZones serial     */
  80.   long           zipTimer;                    /* latest time GetZones called   */
  81.  
  82.   unchar         userName[33] = "\pHacker";   /* UserName (it's sent with msgs)*/
  83.   unchar         zoneName[33] = "\p*";        /* the current zone name         */
  84.  
  85.   unchar         myEntity[1+32+1+32+1+32];    /* entity for NPBLookup requests */
  86.   unchar         namesBuffer[MaxToGet*40];    /* buffer for NBPLookup results  */
  87.   unchar         zonesBuffer[600];            /* buffer for ZIPlist   results  */
  88.   short          namesProcessed;              /* NBPLookup results processed   */
  89.  
  90.   Rect           namesRect,zonesRect;         /* Lists rectangles in the window*/
  91.  
  92.   static BDSElement zipBDS = {0,NIL,0,0};     /* response descr for ZIP calls  */
  93.  
  94.  
  95. /* == Driver routines (called from Think C DA header)  == */
  96.          short DAOpen   (CntrlParam *ctlPB, DCtlPtr dCtl);
  97.          short DAClose  (CntrlParam *ctlPB, DCtlPtr dCtl);
  98.          short DAControl(CntrlParam *ctlPB, DCtlPtr dCtl);
  99.  
  100.   
  101.   /* == Main module routines == */ 
  102.   static void    doCtlEvent (EventRecord*);      /* process a DA event            */
  103.   static void    doEdit     (short);             /* process the Edit Menu commands*/
  104.   static void    doSend     (void);              /* send a message                */
  105.  
  106.   static        void SayError(short);          /* Draw an error message        */
  107.   static pascal void ProcList(DialogPtr,short);/* Draw Names and Zones Lists   */
  108.  
  109.   static void UpdateLists(void);              /* Process Names and Zones Lists */
  110.   static void SendMessage(Str255);            /* Send a message to all selected*/
  111.  
  112.  
  113.   /* === NBPLookup procedures === */
  114.   static short StartLookup(void);
  115.   static void   KillLookup(void);
  116.   static void   FillNames (void);
  117.  
  118.   /* === ZIP GetZoneList procedures === */
  119.   static void  StartZoneList(void);
  120.   static void   KillZoneList(void);
  121.   static void   FillZones   (void);
  122.  
  123.  
  124.   /* === Lists (Names & Zones) procedures == */
  125.   static short   PutList(ListHandle,unchar*,short);
  126.   static short   GetList(ListHandle,unchar*);
  127.   static void  ClearList(ListHandle,long);
  128.  
  129.  
  130. /*
  131.  * This is the main module called from the Think C DA header
  132.  */
  133. main(CntrlParam *ctlPB, DCtlPtr dCtl, short n) {
  134.   short      retcode = noErr;
  135.   GrafPtr       savePort;
  136.   GetPort(&savePort);                         /* save the current GrafPort     */
  137.  
  138.   switch(n) {
  139.   case 0: retcode=DAOpen   (ctlPB,dCtl); break;
  140.   case 2: retcode=DAControl(ctlPB,dCtl); break;
  141.   case 4: retcode=DAClose  (ctlPB,dCtl); break;
  142.   }
  143.   SetPort(savePort);                         /* restore the current GrafPort   */
  144.   return(retcode);
  145. }
  146.  
  147. /*
  148.  * Open the DA: create the window, lists, etc;  start pollings
  149.  */
  150. short DAOpen(CntrlParam *ctlPB, DCtlPtr dCtl) {
  151.   Rect       listRect,sendBox;
  152.   Rect       empty;
  153.   Point      cSize;
  154.   short      itemType,refNum,retcode;
  155.   Handle     item;
  156.   FontInfo   theInfo;
  157.  
  158.   short             namesProcessed;           /* NBPLookup results processed   */
  159.   dCtl->dCtlFlags |=                          /* This DA should be locked, it  */
  160.         dNeedLock | dNeedTime | dNeedGoodBye; /* should be called periodically */
  161.  
  162.  /*
  163.   * If the windowPtr is non-nil, we already have the window opened.
  164.   * This desk accessory ignores multiple opens.
  165.   */
  166.   if(dCtl->dCtlWindow != NIL) return(noErr);
  167.  
  168.   if((retcode = OpenDriver("\p.MPP",&refNum)) != noErr) {
  169.     SysBeep(1);  return(retcode);             /* an attempt to open MPP failed */
  170.   }
  171.  
  172.   theBridge = (unchar)GetBridgeAddress();     /* where is an internet router?  */
  173.     
  174.  /*
  175.   * Think C allocates the pool for the "Globals" itself;
  176.   * We should only check that it hasn't failed
  177.   */
  178.   if(dCtl->dCtlStorage==NIL) return(memFullErr); /* "Globals" allocation failed*/
  179.  
  180.   theResID = 0xC000 |((~dCtl->dCtlRefNum)<<5); /*calculate our DA resource ID  */
  181.  
  182.  /*
  183.   * Create our Dialog window: Get a template from the DA resource file
  184.   */
  185.   theDialog = GetNewDialog(theResID+dialogID,NIL,(WindowPtr)-1);
  186.   if(theDialog == NIL) return(resNotFound);    /* dialog window creation failed*/
  187.  
  188.  /*
  189.   * Set windowKind to the DA refNum, which is negative.
  190.   */
  191.   ((DialogPeek)theDialog)->window.windowKind =       dCtl->dCtlRefNum;
  192.  
  193.  /*
  194.   * Store "our globals" address into refCon to use it from the UserItem processor
  195.   */
  196.   ((DialogPeek)theDialog)->window.refCon     = (long)dCtl->dCtlStorage;
  197.  
  198.  /*
  199.   * Store the windowPtr in the Device Control Entry
  200.   */
  201.   dCtl->dCtlWindow = (WindowPtr)theDialog;
  202.  
  203.  /*
  204.   * Change Dialog Font (I don't know any other way to do it)
  205.   * This DA uses appFont for its Dialog window
  206.   */
  207.   SetPort(theDialog);
  208.   TextFont((*((DialogPeek)theDialog)->textH)->txFont = applFont);
  209.   TextSize((*((DialogPeek)theDialog)->textH)->txSize = 10);
  210.   TextFace(0);
  211.  
  212.  /*
  213.   * Calculate the vertical size of Lists cells
  214.   */
  215.   GetFontInfo(&theInfo);
  216.   cSize.v = theInfo.ascent+theInfo.descent+theInfo.leading;
  217.  
  218.  /*
  219.   * Customize Dialog items: define DrawProc for UserItems (they are Lists)
  220.   */
  221.  
  222.   /* process the List "Listeners Names" */
  223.   GetDItem(theDialog,itList,&itemType,&item,&listRect);
  224.   SetDItem(theDialog,itList, userItem,(Handle)ProcList,&listRect);
  225.   listRect.right -= ScrSize-1;
  226.   namesRect = zonesRect = listRect;
  227.  
  228.   if(theBridge != 0) {                         /* we have a bridge ->          */
  229.     short listV = (listRect.bottom-listRect.top-1)/2/cSize.v*cSize.v;
  230.     namesRect.bottom = namesRect.top   +listV; /* calculate sizes of 2 Lists:  */
  231.     zonesRect.top    = zonesRect.bottom-listV; /* Names List and Zones List    */
  232.  
  233.   } else {                                     /* no bridge found - only 1 List*/
  234.     namesRect.bottom = namesRect.top + (listRect.bottom-listRect.top)/cSize.v*cSize.v;
  235.   }
  236.  
  237.   /* Now create the Names List */
  238.   empty.top   = empty.left = empty.bottom = cSize.v = 0;
  239.   cSize.h     = listRect.right - listRect.left;
  240.   empty.right = 3;                             /* the Names list has 3 columns */
  241.  
  242.   namesList = LNew(&namesRect,&empty,cSize,0,theDialog,TRUE,FALSE,FALSE,TRUE);
  243.   if(namesList == NIL) return(resNotFound);    /* List creation failed         */
  244.  
  245.   /* Now create the Zones List (if necessary) */
  246.   zonesList = NIL;
  247.   if(theBridge != 0) {                         /* there is a bridge here ->    */
  248.     Cell locCell = {0,0};
  249.     empty.right = 2;                           /* the Zones List has 2 columns */
  250.     zonesList = LNew(&zonesRect,&empty,cSize,0,theDialog,TRUE,FALSE,FALSE,TRUE);
  251.     if(zonesList == NIL) return(resNotFound);  /* Zones List creation failed   */
  252.     (*zonesList)->listFlags = lOnlyOne;        /* Only One zone can be selected*/
  253.     PutList(zonesList,(unchar*)"*",1);         /* Local Zone symbol as the 1st */
  254.     LSetSelect(TRUE,locCell,zonesList);        /* element and then select it   */
  255.   } else {                                     /* no bridges -> no zones ->    */
  256.     HideDItem(theDialog,itZones);              /* Hide "Zones" StaticText item */
  257.   }
  258.  
  259.   namesRect.right += ScrSize-1;                /* Add space for scroll bars    */
  260.   zonesRect.right += ScrSize-1; 
  261.  
  262.  /*
  263.   * Customize Dialog items: disable "Send" Button
  264.   */
  265.   GetDItem(theDialog,itSend,&itemType,(Handle*)&sendButton,&sendBox);
  266.   HiliteControl(sendButton,0xFF);
  267.  
  268.  /*
  269.   * Customize Dialog items: Select predefined "Message" text
  270.   */
  271.   SelIText(theDialog,itMessage,0,10000);
  272.  
  273.   /* 
  274.    * Build LookupName: "=:Telex", i.e. all names of type "Telex"
  275.    */
  276.   {unchar* pName = myEntity;
  277.    unchar* pType = (unchar*)ATtype;
  278.    short   pLeng = *pType;
  279.    *pName++ = 1; *pName++ = '=';
  280.    while(pLeng-->=0) *pName++ = *pType++;
  281.   }
  282.  
  283.   /*
  284.    * Build User Name
  285.    */
  286.     { StringHandle sysName = GetString(HomeID);
  287.     if(sysName != NIL) {                       /* OK, "Chooser name" found     */
  288.         short n = 0;                             /* -> move it into userName buff*/
  289.         while(++n <= **sysName && n<=32) userName[n]=(*sysName)[n];
  290.         *userName = n-1;
  291.       }
  292.   }
  293.  
  294.   /* Bring DA window to front */
  295.   ShowWindow(theDialog); SelectWindow(theDialog);
  296.  
  297.   zipRecord.ioResult = askRecord.ioResult = 0; /* emulate successful end of ops*/  
  298.   if( StartLookup() != noErr) {                /* the 1st call of Lookup failed*/
  299.     askRecord.ioResult = 1;                    /* we won't call Lookup any more*/
  300.     SayError(SendIOerr);                       /* show errMessage on screen    */
  301.   }
  302.  
  303.   modNames = TRUE; zipIndex = 0; zipTimer = 0L;
  304.  
  305.   dCtl->dCtlDelay = 3;                         /* call us in 3/60 sec.         */
  306.   return(noErr);
  307. }
  308.  
  309. /*
  310.  * Close the Telex Desk Accessory
  311.  */
  312. short DAClose(CntrlParam *ctlPB, DCtlPtr dCtl) {
  313.   if (dCtl->dCtlWindow != NIL) {               /* there is the DA window opened*/
  314.     KillLookup();                              /* kill pending NBP Lookup call */
  315.     if(zonesList != NIL) KillZoneList();       /* --- " ---    GetZones --"--  */
  316.  
  317.     /* Dispose the Names and Zones Lists */
  318.     if(zonesList != NIL) {LDispose(zonesList); zonesList = NIL;}
  319.     if(namesList != NIL) {LDispose(namesList); namesList = NIL;}
  320.  
  321.     /* Dispose the DA window */
  322.       DisposDialog(theDialog);
  323.       dCtl->dCtlWindow = NIL;
  324.   }
  325.   return(0);
  326. }
  327.  
  328.  
  329. /*
  330.  * Process DA events
  331.  */
  332. short DAControl(CntrlParam *ctlPB, DCtlPtr dCtl) {
  333.   EventRecord  nullRecord;
  334.   EventRecord* theEvent;
  335.   SetPort(theDialog);
  336.  
  337.   switch (ctlPB->csCode) {                     /* What's up ?                  */
  338.   case accCursor: case accEvent:               /* an Apple Event takes place   */
  339.     InitCursor(); /*????*/
  340.     theEvent = *((EventRecord**) &ctlPB->csParam[0]);
  341.     doCtlEvent(theEvent);                      /* process the event            */
  342.     UpdateLists();                             /* update Names and Zones Lists */
  343.  
  344.   break; case accRun:                          /* DA is called after a delay   */
  345.     nullRecord.what = nullEvent;               /* process as a null event      */
  346.     UpdateLists();                             /* Update both Lists            */
  347.       dCtl->dCtlDelay = 30;                      /* O.K. next call - in 1/2 sec  */
  348.  
  349.   break; case accUndo:  case accCut:  case accCopy:
  350.          case accPaste: case accClear:         /* Edit Menu commands:          */
  351.     doEdit(ctlPB->csCode);                     /* process them                 */
  352.  
  353.   break; case goodBye:                         /* the heap is about to die     */
  354.     DAClose(ctlPB,dCtl);                       /* perform the Close sequence   */
  355.  
  356.   }
  357.   return(0);
  358. }
  359.  
  360.  
  361. /*
  362.  * Process Events in the DA
  363.  */
  364. static void doCtlEvent(EventRecord* theEvent) {
  365.   DialogPtr dummy;
  366.   short     itemHit;
  367.   Handle       theItem;
  368.   Rect         theBox;
  369.   short        theType;
  370.  
  371.   /* tune the procedure pointer - DA is floating in RAM (maybe?) */
  372.   GetDItem(theDialog,itList,&theType,&theItem,        &theBox);
  373.   SetDItem(theDialog,itList,userItem,(Handle)ProcList,&theBox);
  374.  
  375.   /* process Command-keys */
  376.   if((theEvent->what == keyDown || theEvent->what==autoKey) &&
  377.      (theEvent->modifiers & cmdKey)) {         /* Is it an Edit menu command   */
  378.     switch((char)theEvent->message) {          /* we have to do it ourselves   */
  379.       case 'X': case 'x': doEdit(accCut);  break;/* not a nice solution, I agree */
  380.       case 'C': case 'c': doEdit(accCopy); break;/* but it's the simplest one    */
  381.       case 'V': case 'v': doEdit(accPaste);break;
  382.       default: SysBeep(1);
  383.     }
  384.  
  385.   /* process ETX-key */
  386.   } else if((theEvent->what == keyDown || theEvent->what==autoKey) &&
  387.             (char)theEvent->message == ETX) {  /* ETX (Enter) key means "Send" */
  388.       doSend();
  389.  
  390.   } else if(DialogSelect(theEvent,&dummy,&itemHit)) { /* hit on an item ?      */
  391.       Point where;
  392.     switch(itemHit) {                          /* what item ?                  */
  393.     case itSend:                               /* "Send" button ->             */
  394.         doSend();                                /*       send the message       */
  395.       break; case itList:                        /* Click in one of the Lists ?  */
  396.         where = theEvent->where;
  397.         GlobalToLocal(&where);
  398.         if(PtInRect(where,&namesRect)) {         /* Click in the Names List ?    */
  399.           if(LClick(where,theEvent->modifiers,namesList)) { /* Process it        */
  400.             doSend();                            /* Double-Click:send the message*/
  401.           }
  402.           modNames = TRUE;                       /* the Names(selection) modified*/
  403.  
  404.         } else if(zonesList != NIL) {            /* Click in the Zones List      */
  405.           LClick(where,theEvent->modifiers,zonesList); /* a new Zone selected    */
  406.         modZones = TRUE;                       /* ZonesList(selection) modified*/
  407.         }
  408.  
  409.       break; case itAbout:                        /* Click in the "About" button */
  410.         Alert(theResID+aboutID,NIL);              /* show our TradeMark, etc.    */
  411.       }
  412.   }
  413.  
  414.   if(theEvent->what == activateEvt) {           /* Activate: (de)activate Lists*/
  415.     LActivate(theEvent->modifiers & activeFlag,namesList);
  416.     if(zonesList != NIL) LActivate(theEvent->modifiers & activeFlag,zonesList);
  417.   }
  418. }
  419.  
  420. /*
  421.  * Execution of the Edit Menu commands(Cut,Copy,Paste,Clear)
  422.  */
  423. static void doEdit(comm) short comm; {
  424.   if(comm == accPaste && TEFromScrap() != noErr) SysBeep(1);
  425.   switch(comm) {
  426.   case accUndo:  SysBeep(1);          break;
  427.   case accCut:   DlgCut(theDialog);   break;
  428.   case accCopy:  DlgCopy(theDialog);  break;
  429.   case accPaste: DlgPaste(theDialog); break;
  430.   case accClear: DlgDelete(theDialog);
  431.   }
  432.   if(comm == accCopy || comm == accCut) {
  433.     ZeroScrap(); TEToScrap();
  434.   }
  435. }
  436.  
  437. /*
  438.  * Show Message in the itError field
  439.  * the procedure gets the String from the STR resource and
  440.  * puts it into the StaticText item in the DA dialog window
  441.  */
  442. void SayError(short code) {
  443.   Handle       theItem;                        /* staticText item attributes   */
  444.   short        theType;
  445.   Rect         theBox;
  446.  
  447.   char*        perror;                         /* error message string         */
  448.   StringHandle theText = NIL;                  /* error message resource       */
  449.  
  450.   /* get the Handle to the StaticText item */
  451.   GetDItem(theDialog,itError,&theType,&theItem,&theBox);
  452.  
  453.   if(code == 0) {                               /* code = 0 -> O.K. -> empty   */
  454.     perror = "\p";
  455.   } else if ((theText=GetString(theResID+code)) != NIL) {
  456.     HLock((Handle)theText);                     /* string is found in STR rsrcs*/
  457.       perror = (char*) *theText;
  458.   } else {                                      /* STR resource is absent ?!   */
  459.     perror = "\pError";                         /* -> use the hard-coded string*/
  460.   }
  461.   SetIText(theItem,perror);                     /* string -> StaticText item   */
  462.   if(theText != NIL) HUnlock((Handle)theText);  /* Unlock the STR resource     */
  463.  
  464.   SetPort(theDialog);  InvalRect(&theBox);      /* force item updating         */
  465.   if(code != 0) SysBeep(1);                     /* error -> Bee-beep!          */
  466. }
  467.  
  468. /*
  469.  * Update UserItem: Names and (optionally) Zones Lists
  470.  */
  471. static pascal void ProcList(DialogPtr myDialog, short itemNo) {
  472.   Rect     xRect;
  473.   Ptr      savedA4 =                            /* this is our "Globals" addr. */
  474.       *(Handle)((DialogPeek)myDialog)->window.refCon;
  475.   asm {                                         /* set A4 to use our "globals" */
  476.     MOVE.L savedA4,D0                           /* D0 = "our A4"               */
  477.     MOVE.L A4,savedA4                           /* current A4 -> savedA4       */
  478.     MOVE.L D0,A4                                /* "our A4"   -> A4            */
  479.   }                                             /* now we can use our Globals  */
  480.  
  481.   SetPort(theDialog);                           /* start drawing Lists         */
  482.   xRect = namesRect; InsetRect(&xRect,-1,-1); FrameRect(&xRect);
  483.   LUpdate(theDialog->visRgn,namesList);         /* The Names List is drawn     */
  484.  
  485.   if(zonesList != NIL) {                        /* if the Zones List is present*/
  486.     xRect = zonesRect; InsetRect(&xRect,-1,-1); FrameRect(&xRect);
  487.     LUpdate(theDialog->visRgn,zonesList);       /* the Zones List is drawn     */
  488.   }
  489.  
  490.   asm {                                         /* Thnx, A4! Now we restore you*/
  491.     MOVE.L savedA4,A4
  492.   }
  493. }
  494.  
  495. /* ==================== DA Lists Processing Routines ========================= */
  496. /*
  497.  * Update Names and Zones Lists
  498.  * 1. Update the Zones List (if any)
  499.  *    if the selected Zone has been changed:
  500.  *        kill pending NBPLookup;
  501.  *        clear the Names List;
  502.  *        restart NBPlookup in the new Zone
  503.  * 2. Update the Names List
  504.  *    if there are selected Names, Highlight the "Send" button
  505.  */
  506. static void UpdateLists() {
  507.   if(zonesList != NIL) {                        /* we have the Zones List      */
  508.     FillZones();                                /* fill New Zones, drop Died   */
  509.     if(modZones) {                              /* the Zone has been changed ? */
  510.       Str32 newZone;
  511.       short lName =0;
  512.       GetList(zonesList,newZone);               /* get the name of the new Zone*/
  513.       if(*newZone == 0) {                       /* no Zone is selected ?       */
  514.         Cell locCell = {0,0};                   /* Select "*" (local) Zone     */
  515.         LSetSelect(TRUE,locCell,zonesList);
  516.         GetList(zonesList,newZone);             /* and get it's name (i.e. "*")*/
  517.       }
  518.  
  519.       /* compare the selected zone with the old one */
  520.       while(lName < *newZone+1 && zoneName[lName] == newZone[lName]) ++lName;
  521.  
  522.       if(lName < *newZone+1) {                  /* the Zone has been changed   */
  523.         while(lName< *newZone+1) {zoneName[lName] = newZone[lName]; ++lName;}
  524.         LDelRow(0,0,namesList);                 /* clear old Obj Names         */
  525.         KillLookup();                           /* kill Names Lookup           */
  526.         askRecord.NBPnumGotten = 0;             /* FillNames will restart it   */
  527.       }
  528.     }
  529.   }
  530.  
  531.   FillNames();                                  /* Update the Names List       */
  532.  
  533.   if(modNames) {                                /* The Names List was changed->*/
  534.     Cell theCell = {0,0};                       /* Hilite the SEND button      */
  535.     HiliteControl(sendButton, LGetSelect(TRUE,&theCell,namesList) ? 0x00 : 0xFF);
  536.     modNames = FALSE;
  537.   }
  538. }
  539.  
  540. /* ================ NBP Lookup operations (the Names List) =================== */
  541. /*
  542.  Algorithm:
  543.  1. Start NBPLookup in the current selected zone (pZone)
  544.  2. when the next Listener (i.e. AT Registered object of type "Telex") is found
  545.          a) if absent, insert it into the Names list (with its AT address)
  546.          b) set the current time into the List element
  547.  3. when the NBPLookup is finished, restart it again
  548.  4. When a listener has died (the latest response >AskPolling secs ago),
  549.     delete that element from the list
  550.  */
  551.  
  552. /*
  553.  * Create the sample name for Lookup and start NBP Lookup call
  554.  */
  555. static short StartLookup() {
  556.   short   lZone = *zoneName+1;                /* length of the Zone Name       */
  557.   unchar* pZone = myEntity;                   /* Ptr to AT object name         */
  558.   pZone += *pZone+1; pZone += *pZone+1;       /* Ptr to AT zone name           */
  559.  
  560.   /* put the Zone Name into NBP entity structure */
  561.   while(--lZone>=0) pZone[lZone] = zoneName[lZone];
  562.  
  563.  
  564.   /* now fill all fields for NBPLookup call */
  565.   askRecord.ioCompletion  = NIL;              /* we don't need ioCompletion    */
  566.   askRecord.MPPcsCode     = tNBPLookup;
  567.   askRecord.NBPinterval   = AskTimeOut;       /* time to wait for responses    */
  568.   askRecord.NBPcount      = 1;                /* no repeats - we'll restart all*/
  569.   askRecord.NBPentityPtr  = (Ptr)myEntity;    /* NBP entity to look for        */
  570.   askRecord.NBPretBuffPtr = (Ptr)namesBuffer; /* Buffer for responses          */
  571.   askRecord.NBPretBuffSize= sizeof(namesBuffer);
  572.   askRecord.NBPmaxToGet   = MaxToGet;         /* Max number of responses       */
  573.  
  574.   namesProcessed = 0;                         /* number of responses processed */
  575.   return(PLookupName(&askRecord,TRUE));       /* start async NBPLookup         */
  576. }
  577.  
  578. /*
  579.  * Kill NBPLookup request (if pending).
  580.  * The routine is used in Close sequence and if the Zone name is changed
  581.  */
  582. static void KillLookup() {
  583.   MPPParamBlock askKill;
  584.   if(askRecord.ioResult > 0) {                /* the NBPLookup req is pending  */
  585.     askKill.MPPnKillQEl = (Ptr)&askRecord;    /* we try to kill this request   */
  586.     PKillNBP(&askKill,FALSE);
  587.   }
  588. }
  589.  
  590.  
  591. /*
  592.  * Process NBP Lookup results.
  593.  * if new (i.e. not processed yet) responses have appeared in the buffer,
  594.  * process them (i.e. insert/update the Names List)
  595.  * Note: Listeners in our Mac are ignored
  596.  *
  597.  * Also check for died Listeners, but not more often than AskPolling/2 secs
  598.  */
  599. static void FillNames() {
  600.   static long lastclear = 0;
  601.   short   retcode;
  602.   unsigned short myNode,myNet;
  603.   GetNodeAddress(&myNode,&myNet);             /* our NodeID, NetID             */
  604.  
  605.   while(namesProcessed<askRecord.NBPnumGotten) { /* cycle for all new responses*/
  606.     Cell       theCell = {0,2};
  607.     EntityName theName;
  608.       AddrBlock  theAddress;
  609.       NBPExtract(namesBuffer,askRecord.NBPnumGotten,namesProcessed+1,
  610.                  &theName,&theAddress);         /* extract the buffer data       */
  611.       if((theAddress.aNet != 0 && theAddress.aNet != myNet) ||
  612.           theAddress.aNode != myNode) {         /* we ignore Listeners in OUR Mac*/
  613.         theCell.v =                             /* put this name into Names List */
  614.                PutList(namesList,theName.objStr+1,*theName.objStr);
  615.         LSetCell((char*)&theAddress,            /* Set the AT addr. into 2 column*/
  616.                  sizeof(theAddress),theCell,namesList);
  617.       }
  618.       ++namesProcessed;
  619.   }
  620.  
  621.   /* if NBPLookup has finished, restart it again, if any Zone is selected */
  622.   if(*zoneName != 0) {
  623.     if(askRecord.ioResult <=0 && (retcode = StartLookup()) != 0) {
  624.       SysBeep(1);                             /* restart failed: Bee-beep!!    */
  625.     }
  626.   }
  627.  
  628.   /* now clear names that are too old */
  629.   if(TickCount()-lastclear >= AskPolling/2) { /*It's the time to check for died*/
  630.     lastclear = TickCount();                  /* remember the current time     */
  631.     ClearList(namesList,lastclear-AskPolling);/* drop anybody who is too old   */
  632.     modNames = TRUE;                          /* Names List could be changed   */
  633.   }
  634. }
  635.  
  636. /* ================ ZIP GetZone operations (the Zones List) ================== */
  637. static void StartZoneList() {
  638.   static struct {unchar cmd,dummy; short index;} theUserBytes = {8,0,0};
  639.  
  640.   zipBDS.buffSize = sizeof(zonesBuffer);      /* prepare data for the ZIP call */
  641.   zipBDS.buffPtr  = (Ptr)zonesBuffer;
  642.   theUserBytes.index = zipIndex;              /* the Index in the router tables*/
  643.  
  644.  
  645.   /* Fill all fields for ATP request to ZIP socket of theBridge */
  646.   zipRecord.ATPioCompletion = NIL;
  647.   zipRecord.ATPreqPointer      = NIL;            /* no data for ZIP GetZones req  */
  648.   zipRecord.ATPreqLength       = 0;              /* everything is in UserBytes    */
  649.   zipRecord.ATPuserData     = *(long*)&theUserBytes;
  650.   zipRecord.ATPcsCode       = tATPSndRequest;
  651.   zipRecord.ATPatpFlags        = 0;
  652.   zipRecord.ATPaddrBlock.aNode   = theBridge; /* we send ZIP requests to the   */
  653.   zipRecord.ATPaddrBlock.aNet    = 0;         /* zipSocket (6) in theBridge    */
  654.   zipRecord.ATPaddrBlock.aSocket = zipSocket;
  655.   zipRecord.ATPnumOfBuffs   = 1;              /* we have 1 buffer for responses*/
  656.   zipRecord.ATPbdsPointer      = (Ptr) &zipBDS;
  657.   zipRecord.ATPtimeOutVal      = ZipTimeOut;
  658.   zipRecord.ATPretryCount      = ZipRepeat;
  659.   if(PSendRequest(&zipRecord,TRUE) != noErr){ /* ZIP GetZoneNames start failed?*/
  660.     SysBeep(1);                               /* failed -> Bee-beep!           */
  661.     zipBDS.userBytes = 0L;                    /* emulate the end of responses  */
  662.   }
  663. }
  664.  
  665. /*
  666.  * Kill pending GetZoneNames ZIP request
  667.  * It is used in CloseDA sequence
  668.  */
  669. static void KillZoneList() {
  670.   ATPParamBlock zipKill;
  671.   if(zipRecord.ioResult > 0) {                /* the ZIP request is pending    */
  672.     zipKill.ATPaKillQEl = (Ptr)&zipRecord;    /* kill it as an ATP request     */
  673.     PKillSendReq(&zipKill,FALSE);
  674.   }
  675. }
  676.  
  677. /*
  678.  * Fill the Zones List
  679.  * if the current request isn't completed yet, do nothing;
  680.  * if there is no request in progress and 
  681.  *    it is the time to refresh the Zones List => Start the ZIP requests serial
  682.  * if a request is completed:
  683.  *   for all Zone Names read:
  684.  *     insert it into the List, if it is a new one;
  685.  *     store the current time to the column #1 of the List
  686.  *   start the next request, if this one isn't the last in the serial
  687.  *   if the response is the last, drop all zones that were missed in this poll
  688.  */
  689. static void FillZones() {
  690.   static long firstTime;
  691.   if(zipRecord.ioResult>0) return;            /* a request isn't completed yet */
  692.  
  693.   if(zipIndex == 0) {                         /* there is no pending request ->*/
  694.     if(TickCount()-zipTimer >= ZipPolling) {  /* if it's time to start polling */
  695.       zipTimer = TickCount();                 /* reset zipIndex to restart it  */
  696.       zipIndex = 1;                           /* at the next call                 */
  697.       PutList(zonesList,(unchar*)"*",1);      /* put Local Zone symbol         */
  698.     }
  699.  
  700.   } else if(zipRecord.ioResult == 0) {        /* a response received           */
  701.     short   nZones = (short) (zipBDS.userBytes & 0xFFFF);
  702.     short   xZones = 0;
  703.     unchar* pNames = zonesBuffer;
  704.  
  705.     if(zipIndex == 1) {                       /* this is the first response    */
  706.       firstTime = TickCount();                /* remember the current time     */
  707.     }
  708.  
  709.     while(xZones++ < nZones) {                /* put Zones names into ZonesList*/
  710.       PutList(zonesList,pNames+1,*pNames);
  711.       pNames += *pNames+1;
  712.     }
  713.  
  714.     if(zipBDS.userBytes & 0xFF000000) {       /* this is the last response ->  */
  715.       ClearList(zonesList,firstTime);         /* drop died zones from the List */
  716.       zipIndex = 0; modZones = TRUE;
  717.     } else {                                  /* we must continue to read all  */
  718.       zipIndex += nZones;                     /* zones from the router         */
  719.     }
  720.   } else {                                    /* ZIP request failed            */
  721.     SysBeep(1);
  722.   }
  723.   if(zipIndex != 0) StartZoneList();          /* continue (or repeat, if error)*/
  724. }
  725.  
  726.  
  727.  
  728. /* ========================= List Procedures =============================== */
  729.  
  730. /*
  731.  * Set data into the List, if it is absent (in the column #0)
  732.  * Set current time to the data row      (into the column #1)
  733.  */
  734. static short PutList(ListHandle theList, unchar* data, short size) {
  735.   Cell       theCell = {0,0};
  736.   boolean    found;
  737.   long       ticks = TickCount();
  738.   while((found = LSearch((Ptr)data,size,NIL,&theCell,theList)) && theCell.h != 0) {
  739.     theCell.h=0; ++theCell.v;                 /* only column #0 is needed      */
  740.   }
  741.  
  742.   if(!found) {                                /* there is a new entity         */
  743.       theCell.v = (*theList)->dataBounds.bottom; theCell.h = 0;
  744.       LAddRow(1,theCell.v,theList);             /* insert the new element        */
  745.     LSetCell((Ptr)data,size,theCell,theList); /* put the data into the 0-column*/
  746.       if(theList==namesList && theCell.v == 0) {/* the first elem in the Names ->*/
  747.         LSetSelect(TRUE,theCell,theList);       /* automatically select it       */
  748.         modNames = TRUE;                        /* Names selection changed!      */
  749.       }
  750.       LDraw(theCell,theList);                   /* draw the new cell             */
  751.   }
  752.  
  753.   theCell.h = 1;                              /* Current Time -> the 1-column  */
  754.   LSetCell((char*)&ticks,sizeof(ticks),theCell,theList);
  755.   return(theCell.v);                          /* return the element number     */
  756. }
  757.  
  758.  
  759. /*
  760.  * Get the selected data (<= 32 bytes) form theList
  761.  * returns the number of the first selected element
  762.  * if no element is selected, returns -1
  763.  */
  764. static short GetList(ListHandle theList, unchar* data) {
  765.   Cell theCell = {0,0};
  766.   if(LGetSelect(TRUE,&theCell,theList)) {     /* is there a selected element?  */
  767.     short length = 32;
  768.     LGetCell(data+1,&length,theCell,theList); /* Get the data from the 0-column*/
  769.     *data = (unchar)length;                   /* set the data length           */
  770.   } else {                                    /* no element is selected ->     */
  771.     theCell.v = -1; *data=0;                  /* return -1 and empty data      */
  772.   }
  773.   return(theCell.v);
  774. }
  775.  
  776. /*
  777.  * Clear theList elements older than limit
  778.  */
  779. static void ClearList(ListHandle theList, long limit) {
  780.   Cell theCell = {0,1};
  781.   while(theCell.v<(*theList)->dataBounds.bottom) {
  782.     long  theTime;                            /* for all rows in theList       */
  783.     short size = sizeof(theTime);
  784.     LGetCell(&theTime,&size,theCell,theList); /* get the time from the column#1*/
  785.  
  786.     if(theTime<limit) LDelRow(1,theCell.v,theList); /* delete the row, if older*/
  787.     else ++theCell.v;                         /* otherwise look at the next one*/
  788.   }
  789. }
  790.  
  791.  
  792. /* ============== Send Messages to the selected Listeners ==================== */
  793.  
  794. /*
  795.  * Send the Message
  796.  * Called: "Send" button or "Enter" key or Double-click in the Names List
  797.  */
  798. static void doSend() {
  799.   Handle   theItem;                           /* Message EditableText attrs    */
  800.   Rect     theBox;
  801.   short    theType;
  802.  
  803.   Str255   theMessage;                        /* Message text                  */
  804.   unchar*  pname;                             /* pointer to the User Name      */
  805.  
  806.   int      i;
  807.  
  808.   /* Get the Message Text */
  809.   GetDItem(theDialog,itMessage,&theType,&theItem,&theBox);
  810.   GetIText(theItem,theMessage);               /* get the text from the Dialog  */
  811.  
  812.   /* Merge with the User Name (if the total length < 0xFF)*/
  813.   pname = userName;
  814.   if((unsigned short) *theMessage + *pname >= 250) *theMessage = 250 - *pname;
  815.   for(i = *pname+1;--i>=0;) theMessage[(unchar)*theMessage+1+i]=pname[i];
  816.  
  817.   SendMessage(theMessage);                    /* send this data to all selected*/
  818.   
  819.   SelIText(theDialog,itMessage,0,10000);      /* Select the text sent          */
  820. }
  821.  
  822. /*
  823.  * Send the formed message data to all selected Listeners
  824.  */
  825. static void SendMessage(Str255 theMessage) {
  826.   Cell           theCell;
  827.     int            retcode;
  828.     short          mySocket = 0;                /* the socket for transactions   */
  829.     AddrBlock      ForAll   = {0,0,0};          /* the socket Mask: no Mask      */
  830.  
  831.     short          theResp;                     /* Listener resp. buffer: errCode*/
  832.   BDSType        BDSArray;                    /* data for a Listener response  */
  833.  
  834.   BDSArray[0].buffSize = sizeof(theResp);     /* fill the response             */
  835.     BDSArray[0].buffPtr  = (Ptr) &theResp;      /*    buffer descriptor          */
  836.  
  837.   /*
  838.      * Open a Socket for transactions with Listeners
  839.      */
  840.   if(ATPOpenSocket(ForAll,&mySocket) != 0) {  /* open a socket to send messages*/
  841.       SayError(SendSysErr);                     /* if it failed, inform the user */
  842.         return;
  843.     }
  844.  
  845.   /*
  846.      * Start of the Send-cycle
  847.      */
  848.   SetCursor(*GetCursor(watchCursor));         /*watch cursor: we do sync-calls */
  849.     
  850.     SayError(0);                                /* Clear the Error Message item  */
  851.  
  852.     theCell.h = theCell.v = 0;
  853.     while(LGetSelect(TRUE,&theCell,namesList)){ /* For all selected Names        */
  854.     ATPParamBlock DialBlock;
  855.         AddrBlock     theAddress;
  856.         short         dataLen = sizeof(theAddress);
  857.  
  858.       /* Get the Listener socket address */
  859.     theCell.h = 2;                            /* the listener AT addr is in the*/
  860.       LGetCell((char*)&theAddress,&dataLen,     /* column #2 of the Names List   */
  861.                theCell,namesList);
  862.         theCell.h = 0;
  863.  
  864.    /*
  865.         * Form the CB for "SendRequest" (Sync)
  866.         */
  867.         DialBlock.ATPioCompletion= NIL;
  868.         DialBlock.ATPcsCode         = tATPSndRequest;
  869.         DialBlock.ATPtimeOutVal  = ReqTimeOut;
  870.         DialBlock.ATPretryCount  = ReqRepeat;
  871.         DialBlock.ATPuserData    = 0;
  872.         DialBlock.ATPatpFlags    = atpXOvalue;
  873.  
  874.         DialBlock.ATPatpSocket   = mySocket;      /* our transaction socket        */
  875.         DialBlock.ATPaddrBlock   = theAddress;    /* Listener AT address           */
  876.  
  877.         DialBlock.ATPreqPointer  = (char*)theMessage;
  878.         DialBlock.ATPreqLength   = *theMessage+1+ /* Message Text + UserName       */
  879.                                            theMessage[*theMessage+1]+1;
  880.         DialBlock.ATPnumOfBuffs  = 1;             /* 1 buffer for response(errCode)*/
  881.         DialBlock.ATPbdsPointer  = (Ptr) BDSArray;/* response buffer: RespWord     */
  882.  
  883.     if( (retcode = PNSendRequest(&DialBlock,TRUE)) == noErr) {
  884.           EventRecord myRecord;                   /* while the sending is pending  */
  885.             while((retcode = DialBlock.ATPioResult) >0) {
  886.                GetNextEvent(0,&myRecord);            /* almost the same as "sync" call*/
  887.             }
  888.         }
  889.  
  890.     if(retcode != 0) {                        /* transaction failed            */
  891.             SayError(SendIOerr);
  892.         } else if (theResp != 0) {                /* Listener's buffer is full     */
  893.             SayError(SendAbFull);
  894.         } else {                                  /* O.K. -> deselect the cell     */
  895.          LSetSelect(FALSE,theCell,namesList);
  896.          modNames = TRUE;
  897.         }
  898.  
  899.       ++theCell.v;
  900.   }
  901.  
  902.   /*
  903.      * End of the Send-cycle
  904.      */
  905.     ATPCloseSocket(mySocket);
  906.   InitCursor();
  907. }