home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / Telephone Manager / Stiletto Sources / Sources / TermWindow.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-04  |  54.5 KB  |  2,000 lines  |  [TEXT/MPS ]
  1. /************************************************************************************************/
  2. /*                                                                                                */
  3. /*    Program Name:    Stiletto                                                                    */
  4. /*                                                                                                */
  5. /*    File Name:        TermWindow.c                                                                */
  6. /*                                                                                                */
  7. /*    © Apple Computer, Inc. 1991-1995                                                            */
  8. /*    All Rights Reserved                                                                            */
  9. /*                                                                                                */
  10. /*    Revision History:                                                                            */
  11. /*                                                                                                */
  12. /*        Date        Who                    Modification                                            */
  13. /*                                                                                                */
  14. /*        1991-07-04    Chris Halim            Original version                                        */
  15. /*        1995-06-26    Jaakko Railo        Version 2.0                                                */
  16. /*                                                                                                */
  17. /************************************************************************************************/
  18.  
  19. /****************************************** DESCRIPTION ******************************************
  20.  
  21. *************************************************************************************************/
  22.  
  23. /******************************************** HEADERS *******************************************/
  24.  
  25. #include "CommResources.h"
  26. #include "Gestalt.h"
  27. #include "Resources.h"
  28. #include "stdio.h"
  29. #include "string.h"
  30. #include "Strings.h"
  31. #include "ToolUtils.h"
  32.  
  33. #include "Telephones.h"
  34.  
  35. #include "Constants.h"
  36. #include "DNHandlers.h"
  37. #include "DNWindow.h"
  38. #include "LogWindow.h"
  39. #include "Preferences.h"
  40. //#include "RPWindow.h"
  41. #include "TermWindow.h"
  42. #include "Utilities.h"
  43.  
  44. /****************************************** DEFINITIONS *****************************************/
  45.  
  46. /****************************************** PROTOTYPES ******************************************/
  47.  
  48. Boolean    DoTelWindowMouseDown (const EventRecord *theEvent);
  49. void    DoTelWindowClick (WindowPtr theWindow, const EventRecord * theEvent);
  50. void    DoTelWindowActivate (WindowPtr theWindow, Boolean becomingActive);
  51. void    DoTelWindowUpdate (WindowPtr theWindow);
  52. void    DoTelWindowOSEvent (const EventRecord *theEvent);
  53. void     DoTelWindowSuspend (Boolean doClipConvert);
  54. void     DoTelWindowResume (Boolean doClipConvert);
  55.  
  56. OSErr    CreateDNList (TelWindowPtr telWindow); 
  57. OSErr    CreateDNWindowList (TelWindowPtr telWindow);
  58. OSErr    DummyCreateDNWindowList (TelWindowPtr telWindow);
  59.  
  60. void    DisplaySelectedDNs (TelWindowPtr telWindow);
  61. void    ShowDNWindow (TelWindowPtr telWindow, short whichDN);
  62.  
  63. OSErr        ListTelTools (void);
  64. TELHandle    CreateTelInfoRec (void);
  65.  
  66. void    HandleTermHookMsg (TELHandle termHand, short mtype, short value);
  67. void    HandleTermKeyMsg (TELHandle termHand, short mtype, short value);
  68. void    HandleTermVolMsg (TELHandle termHand, short mtype, short value);
  69. void    HandleTermDispMsg (TELHandle termHand, short mtype, short value);
  70. void    HandleTermEnableMsg (TELHandle termHand, short mtype, short value);
  71. void    HandleTermOpenMsg (TELHandle termHand, short mtype, short value);
  72. void    HandleTermCloseMsg (TELHandle termHand, short mtype, short value);
  73. void    HandleTermResetMsg (TELHandle termHand, short mtype, short value);
  74. void    HandleTermErrorMsg (TELHandle termHand, short mtype, short value);
  75. void    HandleTermIndHSStateChgMsg (TELHandle termHand, short mtype, short value);
  76. void    HandleTermIndHSConnectMsg (TELHandle termHand, short mtype, short value);
  77. void    HandleTermKeyImmMsg (TELHandle termHand, short mtype, short value);
  78. void    HandleTermVolStateMsg (TELHandle termHand, short mtype, short value);
  79. void    HandleTermOtherMsg (TELHandle termHand, short mtype, short value);
  80.  
  81. void    AdjustInternalDataStructures (TelWindowPtr telWindow);
  82. short    GetConfigString (char * config);
  83.  
  84. void    HandleChoose (TelWindowPtr telWindow);
  85. void    HandleConfig (TelWindowPtr telWindow);
  86. void    HandleSelect (TelWindowPtr telWindow, short modifiers);
  87. //void    HandleRP (TelWindowPtr telWindow, short modifiers);
  88.  
  89. OSErr        CreateFeatureList (TelWindowPtr telWindow); 
  90.  
  91. DNWindowPtr    GetFirstSelectedDNWindow (TelWindowPtr telWindow);
  92.  
  93. void        PrepareGetAnyCADLOGUserItems (DialogPtr theDialog, TelWindowPtr telWindow);
  94. void        BuildAnyCAMenu (MenuHandle theMenu, TelWindowPtr telWindow);
  95. TELCAHandle    GetNthCAFromTelList (short n, TelWindowPtr telWindow);
  96.  
  97. void        PrepareGetAnyDNDLOGUserItems (DialogPtr theDialog, TelWindowPtr telWindow);
  98. void        BuildAnyDNMenu (MenuHandle theMenu, TelWindowPtr telWindow);
  99. TELDNHandle    GetNthDNFromTelList (short n, TelWindowPtr telWindow);
  100.  
  101. /******************************************** GLOBALS *******************************************/
  102.  
  103. extern    LogWindowPtr        gLogWindow;
  104. extern    TelWindowPtr        gTelWindow;
  105.  
  106. extern    TelephoneTermMsgUPP    gTermMsgHandlerUPP;
  107. extern    ModalFilterUPP        gStandardFilterUPP;
  108. extern    UserItemUPP            gDrawBoxUPP;
  109. extern    UserItemUPP            gDrawDefaultUPP;
  110.  
  111. /************************************************************************************************/
  112. /************************************************************************************************/
  113.  
  114.  
  115. #pragma segment Initialize
  116. OSErr    InitCTBManagers (void)
  117. {
  118.     OSErr        errCode = noErr;
  119.     
  120.     if ((errCode = InitCRM ()) == crmNoErr) {
  121.         if ((errCode = InitCTBUtilities ()) == ctbuNoErr) {                
  122.             if ((errCode = InitTEL ()) != noErr)
  123.                 AlertUser ("\pTelephone Manager needs to be installed before using this program !", errCode);
  124.                 
  125.         } else
  126.             AlertUser ("\pInitCTBUtilities Failed !!", errCode);
  127.     } else
  128.         AlertUser ("\pInitCRM Failed !!", errCode);
  129.     
  130.     return (errCode);
  131. }
  132.  
  133.  
  134. #pragma segment Main
  135. short    CreateTelWindow (TelWindowPtr * telWindow, const Rect * windowRect, TELHandle hTEL)
  136. {
  137.     WindowPtr        savedPort;
  138.     Ptr                tPtr;
  139.     short            height;
  140.     Str255            toolName;
  141.     Rect            tRect;
  142.     ControlHandle    theControl;
  143.     OSErr            errCode;
  144.     RgnHandle        grayRgn;
  145.     Ptr                configStr;
  146.     
  147.     /**
  148.      **        Create storage for the window record. We will pass this to GetNewWindow().
  149.      **
  150.      **/
  151.      
  152.     tPtr = NewPtrClear (sizeof (TelWindowRec));
  153.     if (tPtr == nil) {
  154.         AlertUser ("\pNot enough memory to create tel window !", MemError ());
  155.         return (-1);
  156.     }
  157.     
  158.     /**
  159.      **        Get a "WIND" resource for the tel window.
  160.      **
  161.      **/
  162.      
  163.      if (HasColorQD())
  164.         *telWindow = (TelWindowPtr) GetNewCWindow (rTelWIND, tPtr, (WindowPtr)(-1L));
  165.     else
  166.         *telWindow = (TelWindowPtr) GetNewWindow (rTelWIND, tPtr, (WindowPtr)(-1L));
  167.         
  168.     if (*telWindow == nil) {
  169.         AlertUser ("\pUnable to get a WIND resource for tel window!", ResError ());
  170.         DisposPtr (tPtr);
  171.         return (-1);
  172.     }
  173.     
  174.     /**
  175.      **        Move and resize the window according to the rect passed in windowRect.
  176.      **        Also make sure that the window is within the screen boundary.
  177.      **
  178.      **/
  179.      
  180.     grayRgn = GetGrayRgn ();
  181.     if (windowRect && !EmptyRect(windowRect) && RectInRgn (windowRect, grayRgn)) {
  182.         MoveWindow ((WindowPtr) *telWindow, windowRect->left, windowRect->top, false);
  183.         height = windowRect->bottom - windowRect->top;
  184.         SizeWindow ((WindowPtr) *telWindow, windowRect->right - windowRect->left,
  185.                         height, true);
  186.     }
  187.     
  188.     /**
  189.      **        Set the window's characteristics.
  190.      **
  191.      **/
  192.      
  193.     GetPort (&savedPort);
  194.     SetPort ((WindowPtr) *telWindow);
  195.     TextSize (9);
  196.     (void) GetNewControl (rChooseCNTL, (WindowPtr) *telWindow);
  197.     (void) GetNewControl (rConfigCNTL, (WindowPtr) *telWindow);
  198.     (void) GetNewControl (rSelectCNTL, (WindowPtr) *telWindow);
  199.     (void) GetNewControl (rDeselectCNTL, (WindowPtr) *telWindow);
  200. //    (void) GetNewControl (rRPCNTL, (WindowPtr) *telWindow);
  201.  
  202.     theControl = ((WindowPeek) *telWindow)->controlList;
  203.     while (theControl != nil) {
  204.         HiliteControl (theControl, 0xFF);
  205.         theControl = (*theControl)->nextControl;
  206.     }
  207.         
  208.     SetPort (savedPort);
  209.  
  210.     ShowWindow ((WindowPtr) *telWindow);
  211.     
  212.     if (hTEL) {
  213.         (*hTEL)->userData = (long) *telWindow;
  214.         
  215.         (*telWindow)->fTELHandle = hTEL;
  216.  
  217. //        InstallTermHandler (*telWindow);        /* TEMPORARY */
  218.         
  219.         if ((errCode = TELOpenTerm (hTEL)) != noErr)
  220.             PutCLine (gLogWindow, kErrorColor, "### TELOpenTerm failed : %d", errCode);
  221.         else {
  222.             InstallTermHandler (*telWindow);
  223.             
  224.             TELGetToolName ((**(*telWindow)->fTELHandle).procID, toolName);
  225.             SetWTitle ((WindowPtr)*telWindow, toolName);
  226.             
  227.             (void) CreateDNList (*telWindow);
  228.             
  229.             (void) CreateFeatureList (*telWindow);
  230.         }
  231.     }
  232.     else if (ListTelTools () == noErr) {
  233.         if (((*telWindow)->fTELHandle = CreateTelInfoRec ()) != nil) {
  234.             
  235.             (*(*telWindow)->fTELHandle)->userData = (long) *telWindow;
  236.             
  237.             PutLine (gLogWindow, "Config :");
  238.             if ((configStr = TELGetConfig ((*telWindow)->fTELHandle)) != nil)
  239.                 PutLine (gLogWindow, "    %s", configStr);
  240.             else
  241.                 PutCLine (gLogWindow, kErrorColor, "### TELGetConfig failed");
  242.             DisposePtr (configStr);
  243.             
  244.             InstallTermHandler (*telWindow);
  245.             
  246.             TELGetToolName ((**(*telWindow)->fTELHandle).procID, toolName);
  247.             SetWTitle ((WindowPtr)*telWindow, toolName);
  248.             
  249.             (void) CreateDNList (*telWindow);
  250.             
  251.             (void) CreateFeatureList (*telWindow);
  252.         }
  253.     }
  254.     
  255.     SetRect (&tRect, 0,0,0,0);
  256. //    (void) CreateRPWindow (&(*telWindow)->fRPWindow, &tRect, (*telWindow)->fTELHandle);
  257.     
  258. #ifdef DEBUGNOCARD
  259.     
  260.     PutLine (gLogWindow, "Entering no card debug mode.");
  261.     if (CreateDNList (*telWindow) == nil) {}
  262.  
  263. #endif  /* DEBUGNOCARD */
  264.  
  265.     return (noErr);
  266. }
  267.  
  268.  
  269. void    DisposeTelWindow (TelWindowPtr telWindow)
  270. {
  271.     short            item, numOfItems = CountMItems (GetMenu (rFeatureMenu));
  272.     TELHandle        termHand;
  273. //    OSErr            errCode;
  274.     DNWindowPtr        dnWindow, tDNWindow;
  275.     
  276.     termHand = telWindow->fTELHandle;
  277.     
  278.     if (telWindow) {
  279.         
  280.         dnWindow = telWindow->fDNWindowList;
  281.         while (tDNWindow = dnWindow) {
  282.             dnWindow = dnWindow->next;
  283.             DisposeDNWindow (tDNWindow);
  284.         }
  285.         
  286.         if (telWindow->fDNList)
  287.             LDispose (telWindow->fDNList);
  288.         
  289. /*
  290.         FeatureListPtr    theList, previous;
  291.     
  292.         if (theList = telWindow->fFeatureList) {
  293.                 while (theList) {
  294.                     previous = theList;
  295.                     theList = theList->nextFeature;
  296.                     DisposPtr ((Ptr) previous);
  297.                 }
  298.             }
  299. */        
  300.         for (item = numOfItems; item >= 1; --item)
  301.             DelMenuItem (GetMenu (rFeatureMenu), item);
  302.     
  303. //        if (telWindow->fRPWindow)
  304. //            DisposeRPWindow (telWindow->fRPWindow);
  305.         
  306. //        if (termHand) {
  307. //            if ((errCode = TELClrTermMsgHand (termHand, gTermMsgHandlerUPP)) != noErr)
  308. //                PutCLine (gLogWindow, kErrorColor, "### TELClrTermMsgHand failed : %d", errCode);
  309. //                
  310. //            if ((errCode = TELCloseTerm (termHand)) != noErr)
  311. //                PutCLine (gLogWindow, kErrorColor, "### TELCloseTerm fails : %d", errCode);
  312. //
  313. //            if ((errCode = TELDispose (termHand)) != noErr)
  314. //                PutCLine (gLogWindow, kErrorColor, "### TELDispose fails : %d", errCode);
  315. //        }
  316.         
  317.         DisposeWindow ((WindowPtr) telWindow);
  318.     }
  319. }
  320.  
  321.  
  322. Boolean    IsHandledByTelWindow (TelWindowPtr telWindow, const EventRecord * theEvent)
  323. {
  324.     char            key;
  325.     WindowPtr        theWindow;
  326.     Boolean            wasHandled = false;
  327.     TELHandle        termHand = nil;
  328.     
  329.     switch (theEvent->what) {
  330.         case autoKey :
  331.         case keyDown :
  332.             theWindow = FrontWindow ();
  333.             break;
  334.         case mouseDown :
  335.             (void) FindWindow(theEvent->where, &theWindow);
  336.             break;
  337.         default :
  338.             theWindow = (WindowPtr) theEvent->message;
  339.     }
  340.     
  341.     if (GetWRefCon (FrontWindow()) == (long) telWindow->fTELHandle)
  342.         TELEvent (telWindow->fTELHandle, theEvent);
  343.     
  344.     if (telWindow != nil) {
  345.         termHand = telWindow->fTELHandle;
  346.         
  347.         if ((wasHandled = IsHandledByDNWindowList (telWindow->fDNWindowList, theEvent)) == false) {
  348. //          if ((wasHandled = IsHandledByRPWindow (telWindow->fRPWindow, theEvent)) == false) {
  349.             
  350.             switch ( theEvent->what ) {
  351.                 case mouseDown:
  352.                     if (theWindow == (WindowPtr) telWindow) {
  353.                         wasHandled = DoTelWindowMouseDown (theEvent);
  354.                     }
  355.                     break;
  356.                                 
  357.                 case activateEvt:
  358.                     // first give a chance for the tool to update its menu, selection, etc.
  359.                     if (telWindow->fTELHandle != nil)
  360.                         TELActivate (telWindow->fTELHandle, (theEvent->modifiers & activeFlag) != 0);
  361.                     
  362.                     if ((TelWindowPtr) theEvent->message == telWindow) {
  363.                         DoTelWindowActivate ((WindowPtr) telWindow, (theEvent->modifiers & activeFlag) != 0);
  364.                         wasHandled = true;
  365.                     }
  366.                     break;
  367.                     
  368.                 case updateEvt:
  369.                     if ((TelWindowPtr) theEvent->message == telWindow) {
  370.                         DoTelWindowUpdate ((WindowPtr) telWindow);
  371.                         wasHandled = true;
  372.                     }
  373.                     break;
  374.                     
  375.                 case osEvt:
  376.                     
  377.                     if (telWindow->fTELHandle != nil)
  378.                         TELResume (telWindow->fTELHandle, (theEvent->message & resumeFlag) != 0);
  379.                                     
  380.                     if ((TelWindowPtr) FrontWindow () == telWindow) {
  381.                         DoTelWindowOSEvent (theEvent);
  382.                         wasHandled = false;
  383.                     }
  384.                     break;
  385.                     
  386.                 case keyDown:
  387.                 case autoKey:
  388.                     if ((TelWindowPtr) FrontWindow() == telWindow) {
  389.                         key = theEvent->message & charCodeMask;
  390.                         if ( theEvent->modifiers & cmdKey )    {        // Command key is down
  391.                             wasHandled = false;
  392.                         }
  393.                         else {
  394.                             switch (key) {
  395.                                 case leftArrowKey :
  396.                                 case upArrowKey :
  397.                                     SelectPreviousCell (telWindow->fDNList);
  398.                                     wasHandled = true;
  399.                                     break;
  400.                                     
  401.                                 case rightArrowKey :
  402.                                 case downArrowKey :
  403.                                     SelectNextCell (telWindow->fDNList);
  404.                                     wasHandled = true;
  405.                                     break;
  406.                                     
  407.                                 case crKey :
  408.                                 case enterKey :
  409.                                     DisplaySelectedDNs (telWindow);
  410.                                     wasHandled = true;
  411.                                     break;
  412.                                     
  413.                                 case 'd' :
  414.                                     DumpSelectedDNEvents (telWindow);
  415.                                     wasHandled = true;
  416.                                     break;
  417.                                     
  418.                                 case 'D' :
  419.                                     DumpSelectedDNInfo (telWindow);
  420.                                     wasHandled = true;
  421.                                     break;
  422.                                     
  423.                                 case 'e' :
  424.                                 case 'E' :
  425.                                     DumpTermEvents (telWindow);
  426.                                     wasHandled = true;
  427.                                     break;
  428.                                     
  429.                                 case 'i' : 
  430.                                 case 'I' :
  431.                                     DumpTermInfo (telWindow);
  432.                                     wasHandled = true;
  433.                                     break;
  434.                                     
  435.                                 default :
  436.                                     wasHandled = false;
  437.                             }
  438.                         }
  439.                     }
  440.                     break;
  441.                 
  442.                 default :
  443.                     wasHandled = false;
  444.             }
  445. //          }
  446.         }
  447.         
  448.         if (termHand != nil)
  449.             TELIdle (termHand);
  450.     }
  451.     
  452.     return (wasHandled);
  453. }
  454.  
  455.  
  456. Boolean    DoTelWindowMouseDown (const EventRecord *theEvent)
  457. {
  458.     short        part;
  459.     WindowPtr    theWindow;
  460.     Boolean        wasHandled = false;
  461.     
  462.     part = FindWindow(theEvent->where, &theWindow);
  463.     switch ( part ) {            
  464.         case inContent:
  465.             if ( theWindow != FrontWindow() )
  466.                 SelectWindow(theWindow);
  467.  
  468.             DoTelWindowClick (theWindow, theEvent);
  469.             
  470.             wasHandled = true;
  471.             break;
  472.         
  473.         default :
  474.             wasHandled = false;
  475.     }
  476.     
  477.     return (wasHandled);
  478. }
  479.  
  480.  
  481. void    DisplaySelectedDNs (TelWindowPtr telWindow)
  482. {
  483.     Cell        tCell;
  484.  
  485.     SetPt (&tCell, 0, 0);
  486.     while (LGetSelect (true, &tCell, telWindow->fDNList)) {
  487.         ShowDNWindow (telWindow, tCell.v);
  488.         if (! LNextCell (true, true, &tCell, telWindow->fDNList))
  489.             break;
  490.     }
  491. }
  492.  
  493.  
  494. void    DoTelWindowClick (WindowPtr theWindow, const EventRecord * theEvent)
  495. {
  496.     Point            mousePos;
  497.     Boolean            dblClicked;
  498.     WindowPtr        savedPort;
  499.     short            part;
  500.     ControlHandle    theControl;
  501.     
  502.     GetPort    (&savedPort);
  503.     SetPort (theWindow);
  504.     
  505.     mousePos = theEvent->where;
  506.     GlobalToLocal (&mousePos);
  507.  
  508.     if (((TelWindowPtr) theWindow)->fDNList != nil) {
  509.         dblClicked = LClick (mousePos, theEvent->modifiers, ((TelWindowPtr) theWindow)->fDNList);
  510.         
  511.         if (dblClicked == true) {
  512.             DisplaySelectedDNs ((TelWindowPtr) theWindow);
  513.         }
  514.     }
  515.     
  516.     part = FindControl (mousePos, theWindow, &theControl);
  517.     switch (part) {
  518.         case 0 :        // invisible or inactive control was clicked
  519.             break;
  520.         
  521.         case inThumb :
  522.             break;
  523.         
  524.         case inButton :
  525.             part = TrackControl (theControl, mousePos, nil);
  526.             if (part != 0) {
  527.                 switch (GetCRefCon (theControl)) {
  528.                     case rChooseCNTL :
  529.                         HandleChoose ((TelWindowPtr) theWindow);
  530.                         break;
  531.                         
  532.                     case rConfigCNTL :
  533.                         HandleConfig ((TelWindowPtr) theWindow);
  534.                         break;
  535.                         
  536.                     case rSelectCNTL :
  537.                         HandleSelect ((TelWindowPtr) theWindow, theEvent->modifiers);
  538.                         break;
  539.                         
  540.                     case rDeselectCNTL :
  541.                         HandleSelect ((TelWindowPtr) theWindow, true);
  542.                         break;
  543.                         
  544. //                    case rRPCNTL :
  545. //                        HandleRP ((TelWindowPtr) theWindow, theEvent->modifiers);
  546. //                        break;
  547.                 }
  548.             }
  549.             break;
  550.         
  551.         case inCheckBox:
  552.             break;
  553.     }
  554.  
  555.     SetPort (savedPort);
  556. }
  557.  
  558.  
  559. void    DoTelWindowActivate (WindowPtr theWindow, Boolean becomingActive)
  560. {
  561.     WindowPtr        savedPort;
  562.     ControlHandle    theControl;
  563.     
  564.     GetPort (&savedPort);
  565.     SetPort (theWindow);
  566.     
  567.     theControl = ((WindowPeek) theWindow)->controlList;
  568.     while (theControl != nil) {
  569.         HiliteControl (theControl, (becomingActive)? 0 : 255);
  570.         theControl = (*theControl)->nextControl;
  571.     }
  572.     
  573.     if (((TelWindowPtr) theWindow)->fDNList != nil)
  574.         LActivate (becomingActive, ((TelWindowPtr) theWindow)->fDNList);
  575.  
  576.     SetPort (savedPort);
  577. }
  578.  
  579.  
  580. void    DoTelWindowUpdate (WindowPtr theWindow)
  581. {
  582.     WindowPtr    savedPort;
  583.     Rect        tRect;
  584.     
  585.     BeginUpdate (theWindow);    
  586.     if ( ! EmptyRgn (theWindow->visRgn) )
  587.     {
  588.         GetPort (&savedPort);
  589.         SetPort (theWindow);
  590.         
  591. //        EraseRect(&theWindow->portRect);
  592.         UpdtControl (theWindow, theWindow->visRgn);
  593.         
  594.         if (((TelWindowPtr) theWindow)->fDNList != nil) {
  595.             LUpdate (theWindow->visRgn, ((TelWindowPtr) theWindow)->fDNList);
  596.             
  597.             tRect = (*((TelWindowPtr) theWindow)->fDNList)->rView;
  598.             InsetRect (&tRect, -1, -1);
  599.             FrameRect (&tRect);
  600.         }
  601.         SetPort (savedPort);
  602.     }
  603.     EndUpdate (theWindow);
  604. }
  605.  
  606.  
  607. void    DoTelWindowOSEvent (const EventRecord *theEvent)
  608. {
  609.     Boolean doConvert;
  610.     unsigned char evType;
  611.  
  612.     evType = (unsigned char) (theEvent->message >> 24) & 0x00ff; // Get the high byte.
  613.     switch (evType) {                     // The high byte of message is the type of event.
  614.         case suspendResumeMessage :
  615.             doConvert = (theEvent->message & convertClipboardFlag) != 0;
  616.             
  617.             if ((theEvent->message & resumeFlag) == 0)
  618.                 DoTelWindowSuspend (doConvert);
  619.             else
  620.                 DoTelWindowResume (doConvert);
  621.             break;
  622.     }
  623. }
  624.  
  625.  
  626. void     DoTelWindowSuspend (Boolean doClipConvert)
  627. {
  628. #pragma unused (doClipConvert)
  629.  
  630.     DoTelWindowActivate (FrontWindow(), false);
  631. }
  632.  
  633.  
  634. void     DoTelWindowResume (Boolean doClipConvert)
  635. {
  636. #pragma unused (doClipConvert)
  637.  
  638.     InitCursor ();
  639.     DoTelWindowActivate (FrontWindow(), true);
  640. }
  641.  
  642.  
  643. OSErr    CreateDNList (TelWindowPtr telWindow)
  644. {
  645.     Rect    rView, dataBounds;
  646.     Point    cSize;
  647.     Rect    **rectHandle;
  648.     
  649.     SetRect (&dataBounds, 0, 0, 1, 0);            // one-column list
  650.     
  651.     SetPt (&cSize, 0, 0);                        // use default cell size
  652.  
  653.     rectHandle = (Rect **) Get1Resource ('RECT', rDNListRECT);
  654.     if (rectHandle) {
  655.         rView = **rectHandle;
  656.         rView.right -= 15;
  657.         ReleaseResource ((Handle) rectHandle);
  658.     } else {
  659.         rView = ((WindowPtr) telWindow)->portRect;    // the rect where list is displayed
  660.         rView.right -= 15;
  661.     }
  662.     
  663.     if ((telWindow->fDNList = lnew (&rView, &dataBounds, &cSize, 0, (WindowPtr)telWindow,
  664.             true, false, false, true)) != nil) {
  665.             
  666.             LActivate (false, telWindow->fDNList);
  667.             
  668. #ifdef DEBUGNOCARD
  669.         return (DummyCreateDNWindowList (telWindow));
  670. #else
  671.         return (CreateDNWindowList (telWindow));
  672. #endif  /* DEBUGNOCARD */
  673.     }
  674.     else
  675.         return (MemError());
  676. }
  677.  
  678.  
  679. #ifdef DEBUGNOCARD
  680. OSErr    DummyCreateDNWindowList (TelWindowPtr telWindow)
  681. {
  682.     OSErr                errCode = noErr;
  683.     short                numOfDNs, index;
  684.     TELDNHandle    dnHand = nil;
  685.     DNWindowPtr            *tDNWindow;
  686.     Cell                tCell;
  687.     char                *dn[3];
  688.     
  689.     dn[0] = "12345";
  690.     dn[1] = "67890";
  691.     dn[2] = "chris";
  692.     
  693.     tDNWindow = &telWindow->fDNWindowList;
  694.     
  695.     numOfDNs = 3;
  696.     
  697.     for (index = 1; index <= numOfDNs; ++index) {
  698.         *tDNWindow = CreateDNWindow (dnHand, dn[index-1]);
  699.         if (*tDNWindow != nil) {
  700.             tDNWindow = &(*tDNWindow)->next;
  701.             
  702.             SetPt (&tCell, 0, index-1);
  703.             LAddRow (1, index-1, telWindow->fDNList);
  704.             LSetCell (dn[index-1], 5, tCell, telWindow->fDNList);
  705.         }
  706.         else
  707.             PutCLine (gLogWindow, kErrorColor, "### CreateDNWindow fails");
  708.     }
  709.     
  710.     if (numOfDNs > 0) {                                // hilite the first row & column
  711.         SetPt (&tCell, 0, 0);                        
  712.         LSetSelect (true, tCell, telWindow->fDNList);
  713.     }
  714.     
  715.     return (errCode);
  716. }
  717. #endif  /* DEBUGNOCARD */
  718.  
  719.  
  720. OSErr    CreateDNWindowList (TelWindowPtr telWindow)
  721. {
  722.     OSErr                errCode;
  723.     TELHandle            termHand;
  724.     Boolean                physical = false;  //false means both logical & physical DNs
  725.     short                numOfDNs = 0, index;
  726.     TELDNHandle            dnHand;
  727.     DNWindowPtr            *tDNWindow;
  728.     Cell                tCell;
  729.     Str31                 title;
  730.     short                len;
  731.     Str255                tString;
  732.  
  733.     termHand = telWindow->fTELHandle;
  734.     tDNWindow = &telWindow->fDNWindowList;
  735.     
  736.     if (termHand != nil) {        
  737.         numOfDNs = TELCountDNs (termHand, telAllDNs, physical);
  738.         
  739.         for (index = 1; index <= numOfDNs; ++index) {
  740.             errCode = TELDNLookupByIndex (termHand, telAllDNs, physical, index, &dnHand);
  741.             if (errCode == noErr) {
  742.                 sprintf ((char *) title, "dnHand = 0x%x", dnHand);
  743.                 *tDNWindow = CreateDNWindow (dnHand, (char *) title);
  744.                 if (*tDNWindow != nil) {
  745.                     tDNWindow = &(*tDNWindow)->next;
  746.                     
  747.                     SetPt (&tCell, 0, index-1);
  748.                     LAddRow (1, index-1, telWindow->fDNList);
  749.  
  750. //                    LSetCell ((*dnHand)->dn+1, (*dnHand)->dn[0], tCell, telWindow->fDNList);
  751. //                    len = sprintf ((char *) tString, "0x%08x   %s", dnHand, (*dnHand)->dn+1);
  752.                     len = sprintf ((char *) tString, "0x%08x", dnHand);
  753.                     LSetCell (tString, len, tCell, telWindow->fDNList);
  754.  
  755.                 }
  756.                 else
  757.                     if ((errCode = TELDNDispose (dnHand)) != noErr)
  758.                         PutCLine (gLogWindow, kErrorColor, "### TELDNDispose fails : %d", errCode);
  759.             }
  760.             else
  761.                 PutCLine (gLogWindow, kErrorColor, "### TELDNLookupByIndex fails : %d", errCode);
  762.         }
  763.     }
  764.     else
  765.         PutCLine (gLogWindow, kErrorColor, "### Invalid termHand");
  766.     
  767.     if (numOfDNs > 0) {                                // hilite the first row & column
  768.         SetPt (&tCell, 0, 0);                        
  769.         LSetSelect (true, tCell, telWindow->fDNList);
  770.         DoTelWindowActivate ((WindowPtr) telWindow, false);    // deactivate list since there is at least 1 dn window in front of this window
  771.     }
  772.     
  773.     return (errCode);
  774. }
  775.  
  776.  
  777. OSErr    ListTelTools (void)
  778. {
  779.     OSErr    errCode = noErr;
  780.     Str255    toolName;
  781.     short    index = 1;
  782.     
  783.     PutLine (gLogWindow, "Scanning telephone tools :");
  784.     
  785.     while (errCode == noErr) {
  786.         errCode = CRMGetIndToolName(classTEL, index, toolName);
  787.         ++index;
  788.         
  789.         if (errCode == noErr) {
  790.             PutLine (gLogWindow, "   %s", p2cstr(toolName));
  791.         }
  792.     }
  793.     
  794.     if (index == 2) {
  795.         PutCLine (gLogWindow, kErrorColor, "### No telephone tool was found !");
  796.         errCode = -1;
  797.     }
  798.     else
  799.         errCode = noErr;
  800.     
  801.     return (errCode);
  802. }
  803.  
  804.  
  805. short    DisplayNewFlagsDialog (long *newFlags)
  806. {
  807.     DialogPtr    theDialog;
  808.     short        itemHit = nil;
  809.     short        returnValue;
  810.     short        itemType;
  811.     Handle        item;
  812.     Rect        box;
  813.     short        itemKind;
  814.     Handle        itemHand;
  815.     Rect        itemRect;
  816.     Boolean        checkBoxState;
  817.     
  818.     theDialog = GetNewDialog (rNewFlagsDLOG, nil, (WindowPtr)(-1L));
  819.     if (theDialog == nil) {
  820.         AlertUser ("\pUnable to get a DLOG resource!", ResError());
  821.         return (-1);
  822.     }
  823.     GetDialogItem (theDialog, kNewFlagsDefault, &itemType, &item, &box);
  824.     SetDialogItem (theDialog, kNewFlagsDefault, itemType, (Handle) gDrawDefaultUPP, &box);
  825.  
  826.     ShowWindow (theDialog);
  827.     while ((itemHit != ok) && (itemHit != cancel)) {
  828.         ModalDialog (gStandardFilterUPP, &itemHit);
  829.         checkBoxState = ToggleCheckBox (theDialog, itemHit);
  830.     }
  831.     HideWindow (theDialog);
  832.     *newFlags = 0;
  833.     switch (itemHit) {
  834.         case ok :
  835.             GetDialogItem (theDialog, kNewFlagsNoMenusItem, &itemKind, &itemHand, &itemRect);
  836.             if (GetControlValue ((ControlHandle) itemHand) == 1)
  837.                 *newFlags = telNoMenus;
  838.             GetDialogItem (theDialog, kNewFlagsQuietItem, &itemKind, &itemHand, &itemRect);
  839.             if (GetControlValue ((ControlHandle) itemHand) == 1)
  840.                 *newFlags = *newFlags | telQuiet;
  841.             GetDialogItem (theDialog, kNewFlagsConfigChangedItem, &itemKind, &itemHand, &itemRect);
  842.             if (GetControlValue ((ControlHandle) itemHand) == 1)
  843.                 *newFlags = *newFlags | telConfigChanged;
  844.             returnValue = ok;
  845.             break;
  846.         default :
  847.             returnValue = cancel;
  848.     }
  849.     DisposDialog (theDialog);
  850.     return (returnValue);
  851. }
  852.  
  853.  
  854. TELHandle    CreateTelInfoRec (void)
  855. {
  856.     OSErr            errCode = noErr;
  857.     Str255            toolName;
  858.     short            i, procId = -1;
  859.     TELHandle        theTerm = nil;
  860.     Point            chooseOrigin;
  861.     TELErr            telErrCode;
  862.     long            newFlags;
  863.     long            response;
  864.     
  865.     
  866.     DisplayNewFlagsDialog (&newFlags);
  867.     
  868.     for (i=1; theTerm == nil; i++) {
  869.         errCode = noErr;
  870.  
  871. //        errCode = CRMGetIndToolName(classTEL, i, toolName);
  872. //        if (*toolName == nil || errCode != noErr) {
  873. //            PutLine (gLogWindow, "Couldn't get any tools!");
  874. //            break;
  875. //        }
  876. //        procId = TELGetProcID (toolName);
  877. //        if (procId == -1) {
  878. //            PutLine (gLogWindow, "Couldn't get proc ID for tool %s!", p2cstr(toolName));
  879. //            break;
  880. //        }
  881. //        theTerm = TELNew (procId, telNoMenus|telQuiet|telConfigChanged, 0, 0, &telErrCode);        // telConfigChanged ??
  882. //        if (telErrCode != noErr) {
  883. //            PutLine (gLogWindow, "### TELNew failed : %d", telErrCode);
  884. //            break;
  885. //        }
  886.  
  887.         errCode = CRMGetIndToolName(classTEL, i, toolName);
  888.         if (errCode != noErr) {
  889.             PutLine (gLogWindow, "### CRMGetIndToolName failed : %d", errCode);
  890.             break;
  891.         }
  892.         if (*toolName == nil) {
  893.             PutLine (gLogWindow, "### Couldn't get any tools!");
  894.             break;
  895.         }
  896.  
  897.         procId = TELGetProcID (toolName);
  898.         if (procId == -1)
  899.             PutLine (gLogWindow, "### Couldn't get proc ID for %*.*s!", toolName[0], toolName[0], &toolName[1]);
  900.         else 
  901.         {
  902.             
  903.             if ((errCode = Gestalt (gestaltTeleMgrAttr, &response)) == noErr) 
  904.             {
  905.                 
  906.                 if (response & (1 << gestaltTeleMgrNewTELNewSupport))
  907.                 {
  908.                     theTerm = TELNewWithResult (procId, newFlags, 0, 0, &telErrCode);
  909.                     if (telErrCode != noErr)
  910.                         PutLine (gLogWindow, "### TELNewWithResult for %*.*s failed : %d", toolName[0], toolName[0], &toolName[1], telErrCode);
  911.                 }
  912.                 else 
  913.                     theTerm = TELNew (procId, newFlags, 0, 0);
  914.             }
  915.             else
  916.                 PutLine (gLogWindow, "### Gestalt failed");
  917.         }
  918.     }
  919.     
  920.     chooseOrigin.v = 80;
  921.     chooseOrigin.h = 80;
  922.     if (procId != -1) {
  923.         errCode = TELChoose (&theTerm, chooseOrigin, nil);
  924.         if (theTerm != nil) {
  925.             if ((errCode = TELOpenTerm (theTerm)) != noErr) {
  926.                 PutCLine (gLogWindow, kErrorColor, "### TELOpenTerm fails : %d", errCode);
  927.                 if ((errCode = TELDispose (theTerm) != noErr)) {
  928.                     PutCLine (gLogWindow, kErrorColor, "### TELDispose fails : %d", errCode);
  929.                     theTerm = nil;
  930.                 }
  931.             }
  932.         }
  933.     }
  934.     else
  935.         theTerm = nil;
  936.         
  937.     return theTerm;
  938. }
  939.  
  940.  
  941. #pragma segment Dump
  942. void    DumpTermInfo (TelWindowPtr telWindow)
  943. {
  944.     OSErr                errCode;
  945.     long                flags;
  946.     TELHandle            termHand;
  947.     TELTermPtr    tTermInfoRecPtr;
  948.     
  949.     termHand = telWindow->fTELHandle;
  950.     
  951.     if (termHand != nil) {
  952.         if ((errCode = TELGetInfo (termHand)) == noErr) {
  953.             PutLine (gLogWindow, "=============== TELRecord ===============");
  954.             PutLine (gLogWindow, " procID             : %04x", (**termHand).procID);
  955.             PutLine (gLogWindow, " flags              : %08x", (**termHand).flags);
  956.             PutLine (gLogWindow, " reserved           : %08x", (**termHand).reserved);
  957.             PutLine (gLogWindow, " refCon             : %08x", (**termHand).refCon);
  958.             PutLine (gLogWindow, " userData           : %08x", (**termHand).userData);
  959.             PutLine (gLogWindow, " defProc            : %08x", (**termHand).defproc);
  960.             PutLine (gLogWindow, " config             : %08x", (**termHand).config);
  961.             PutLine (gLogWindow, " oldConf            : %08x", (**termHand).oldConfig);
  962.             PutLine (gLogWindow, " pTELTerm           : %d", (**termHand).pTELTerm);
  963.             PutLine (gLogWindow, " telPrivate         : %08x", (**termHand).telPrivate);
  964.             PutLine (gLogWindow, " reserved1          : %08x", (**termHand).reserved1);
  965.             PutLine (gLogWindow, " reserved2          : %08x", (**termHand).reserved2);
  966.             PutLine (gLogWindow, " pTELTermSize       : %d", (**termHand).pTELTermSize);
  967.             PutLine (gLogWindow, " version            : %d", (**termHand).version);
  968.             
  969.             tTermInfoRecPtr = (**termHand).pTELTerm;
  970.             
  971.             PutLine (gLogWindow, "=============== TELTermRecord ============");
  972.             PutLine (gLogWindow, " tRef                 : %04x", (*tTermInfoRecPtr).tRef);
  973.             
  974.             flags = (*tTermInfoRecPtr).featureFlags;
  975.             PutLine (gLogWindow, " featureFlags         : %08x", flags);
  976.             PutLine (gLogWindow, " %c pcmAvail", (flags & pcmAvail)?checkChar:spaceChar);
  977.             PutLine (gLogWindow, " %c hasHandset", (flags & hasHandset)?checkChar:spaceChar);
  978.             PutLine (gLogWindow, " %c hasSpeakerphone", (flags & hasSpeakerphone)?checkChar:spaceChar);
  979.             PutLine (gLogWindow, " %c canOnHookDial", (flags & canOnHookDial)?checkChar:spaceChar);
  980.             PutLine (gLogWindow, " %c hasRinger", (flags & hasRinger)?checkChar:spaceChar);
  981.             PutLine (gLogWindow, " %c canSetDisplay", (flags & canSetDisplay)?checkChar:spaceChar);
  982.             PutLine (gLogWindow, " %c hasKeypad", (flags & hasKeypad)?checkChar:spaceChar);
  983.             PutLine (gLogWindow, " %c hasVideo", (flags & hasVideo)?checkChar:spaceChar);
  984.             PutLine (gLogWindow, " %c hasOther", (flags & hasOther)?checkChar:spaceChar);
  985.             PutLine (gLogWindow, " %c crossDNConference", (flags & crossDNConference)?checkChar:spaceChar);
  986.             PutLine (gLogWindow, " %c hasSubaddress", (flags & hasSubaddress)?checkChar:spaceChar);
  987.             PutLine (gLogWindow, " %c hasUserUserInfo", (flags & hasUserUserInfo)?checkChar:spaceChar);
  988.             PutLine (gLogWindow, " %c hasHandsetSoundStreams", (flags & hasHandsetSoundStreams)?checkChar:spaceChar);
  989.             PutLine (gLogWindow, " %c hasIndHandset", (flags & hasIndHandset)?checkChar:spaceChar);
  990.             PutLine (gLogWindow, " %c hasBuiltinSpeakerphone", (flags & hasBuiltinSpeakerphone)?checkChar:spaceChar);
  991.             PutLine (gLogWindow, "  remainder             : %08x", (flags & (0xFFFFFFFF << 15)));
  992.             
  993.             PutLine (gLogWindow, " handsetSpeakerVol    : %d", (*tTermInfoRecPtr).handsetSpeakerVol);
  994.             PutLine (gLogWindow, " handsetMicVol        : %d", (*tTermInfoRecPtr).handsetMicVol);
  995.             PutLine (gLogWindow, " speakerphoneVol      : %d", (*tTermInfoRecPtr).speakerphoneVol);
  996.             PutLine (gLogWindow, " speakerphoneMicVol   : %d", (*tTermInfoRecPtr).speakerphoneMicVol);
  997.             PutLine (gLogWindow, " builtinSpeakerVol    : %d", (*tTermInfoRecPtr).builtinSpeakerVol);
  998.             PutLine (gLogWindow, " builtinSpeakerMicVol : %d", (*tTermInfoRecPtr).builtinSpeakerMicVol);
  999.             PutLine (gLogWindow, " ringerVol            : %d", (*tTermInfoRecPtr).ringerVol);
  1000.             PutLine (gLogWindow, " otherVol             : %d", (*tTermInfoRecPtr).otherVol);
  1001.             PutLine (gLogWindow, " ringerTypes          : %04x", (*tTermInfoRecPtr).ringerTypes);
  1002.             PutLine (gLogWindow, " hasDisplay           : %d", (*tTermInfoRecPtr).hasDisplay);
  1003.             PutLine (gLogWindow, " displayRows          : %d", (*tTermInfoRecPtr).displayRows);
  1004.             PutLine (gLogWindow, " numDNs               : %d", (*tTermInfoRecPtr).numDNs);
  1005.             PutLine (gLogWindow, " maxAllocCA           : %d", (*tTermInfoRecPtr).maxAllocCA);
  1006.             PutLine (gLogWindow, " curAllocCA           : %d", (*tTermInfoRecPtr).curAllocCA);
  1007.             PutLine (gLogWindow, " reserved             : %08x", (*tTermInfoRecPtr).reserved);
  1008.         }
  1009.         else
  1010.             PutCLine (gLogWindow, kErrorColor, "### TELGetInfo fails : %d", errCode);
  1011.     }
  1012.     else
  1013.         PutCLine (gLogWindow, kErrorColor, "### Invalid termHand");
  1014. }
  1015.  
  1016.  
  1017. #pragma segment Dump
  1018. void    DumpTermEvents (TelWindowPtr telWindow)
  1019. {
  1020.     OSErr            errCode;
  1021.     TELHandle        termHand;
  1022.     long            eventMask;
  1023.     
  1024.     termHand = telWindow->fTELHandle;
  1025.     
  1026.     if (termHand != nil) {
  1027.         if ((errCode = TELTermEventsSupp (termHand, &eventMask)) == noErr) {
  1028.             PutLine (gLogWindow, "=============== TermEvents ===============");
  1029.             PutLine (gLogWindow, " mask         : %08x", eventMask);
  1030.             PutLine (gLogWindow, " %c telTermHookMsg", (eventMask & telTermHookMsg)?checkChar:spaceChar);
  1031.             PutLine (gLogWindow, " %c telTermKeyMsg", (eventMask & telTermKeyMsg)?checkChar:spaceChar);
  1032.             PutLine (gLogWindow, " %c telTermVolMsg", (eventMask & telTermVolMsg)?checkChar:spaceChar);
  1033.             PutLine (gLogWindow, " %c telTermDisplayMsg", (eventMask & telTermDisplayMsg)?checkChar:spaceChar);
  1034.             PutLine (gLogWindow, " %c telTermEnableMsg", (eventMask & telTermEnableMsg)?checkChar:spaceChar);
  1035.             PutLine (gLogWindow, " %c telTermOpenMsg", (eventMask & telTermOpenMsg)?checkChar:spaceChar);
  1036.             PutLine (gLogWindow, " %c telTermCloseMsg", (eventMask & telTermCloseMsg)?checkChar:spaceChar);
  1037.             PutLine (gLogWindow, " %c telTermResetMsg", (eventMask & telTermResetMsg)?checkChar:spaceChar);
  1038.             PutLine (gLogWindow, " %c telTermErrorMsg", (eventMask & telTermErrorMsg)?checkChar:spaceChar);
  1039.             PutLine (gLogWindow, " %c telTermIndHSStateChgMsg", (eventMask & telTermIndHSStateChgMsg)?checkChar:spaceChar);
  1040.             PutLine (gLogWindow, " %c telTermIndHSConnectMsg", (eventMask & telTermIndHSConnectMsg)?checkChar:spaceChar);
  1041.             PutLine (gLogWindow, " %c telTermKeyImmMsg", (eventMask & telTermKeyImmMsg)?checkChar:spaceChar);
  1042.             PutLine (gLogWindow, " %c telTermVolStateMsg", (eventMask & telTermVolStateMsg)?checkChar:spaceChar);
  1043.             PutLine (gLogWindow, " %c telTermOtherMsg", (eventMask & telTermOtherMsg)?checkChar:spaceChar);
  1044.             PutLine (gLogWindow, " remainder      : %08x", (eventMask & ~(telAllTermMsgs | telTermOtherMsg)));
  1045.         }
  1046.         else
  1047.             PutCLine (gLogWindow, kErrorColor, "### TELTermEventsSupp fails : %d", errCode);
  1048.     }
  1049.     else
  1050.         PutCLine (gLogWindow, kErrorColor, "### Invalid termHand");
  1051. }
  1052.  
  1053.  
  1054. #pragma segment Main
  1055. pascal void    AllTermMsgsHandler (TELHandle termHand, long msg, short mtype, short value, long ourA5)
  1056. {
  1057. #pragma unused (mtype, value)
  1058.  
  1059.     long    oldA5;
  1060.     char    *msgString;
  1061.     
  1062.     oldA5 = SetA5 (ourA5);
  1063.     
  1064.     switch (msg) {
  1065.         case telTermHookMsg                : msgString = "telTermHookMsg"; break;
  1066.         case telTermKeyMsg                : msgString = "telTermKeyMsg"; break;
  1067.         case telTermVolMsg                : msgString = "telTermVolMsg"; break;
  1068.         case telTermDisplayMsg            : msgString = "telTermDisplayMsg"; break;
  1069.         case telTermEnableMsg            : msgString = "telTermEnableMsg"; break;
  1070.         case telTermOpenMsg                : msgString = "telTermOpenMsg"; break;
  1071.         case telTermCloseMsg            : msgString = "telTermCloseMsg"; break;
  1072.         case telTermResetMsg            : msgString = "telTermResetMsg"; break;
  1073.         case telTermErrorMsg            : msgString = "telTermErrorMsg"; break;
  1074.         case telTermIndHSStateChgMsg    : msgString = "telTermIndHSStateChgMsg"; break;
  1075.         case telTermIndHSConnectMsg        : msgString = "telTermIndHSConnectMsg"; break;
  1076.         case telTermKeyImmMsg            : msgString = "telTermKeyImmMsg"; break;
  1077.         case telTermVolStateMsg            : msgString = "telTermVolStateMsg"; break;
  1078.         case telTermOtherMsg            : msgString = "telTermOtherMsg"; break;
  1079.             
  1080.         default :
  1081.             PutCLine (gLogWindow, kErrorColor, "### Unknown termMsg : %08x", msg);
  1082.             msgString = "### Unknown";
  1083.     }
  1084.                 
  1085.     PutLine (gLogWindow, ">>> got a Term message (%08x) : %s", termHand, msgString);
  1086.     
  1087.     (void) SetA5 (oldA5);
  1088. }
  1089.  
  1090.  
  1091. pascal void    TermMsgHandler (TELHandle termHand, long msg, short mtype, short value, long ourA5)
  1092. {
  1093.     long    oldA5;
  1094.     
  1095.     oldA5 = SetA5 (ourA5);
  1096.     
  1097.     switch (msg) {
  1098.         case telTermHookMsg :
  1099.             HandleTermHookMsg (termHand, mtype, value);
  1100.             break;
  1101.             
  1102.         case telTermKeyMsg :
  1103.             HandleTermKeyMsg (termHand, mtype, value);
  1104.             break;
  1105.             
  1106.         case telTermVolMsg :
  1107.             HandleTermVolMsg (termHand, mtype, value);
  1108.             break;
  1109.             
  1110.         case telTermDisplayMsg :
  1111.             HandleTermDispMsg (termHand, mtype, value);
  1112.             break;
  1113.             
  1114.         case telTermEnableMsg :
  1115.             HandleTermEnableMsg (termHand, mtype, value);
  1116.             break;
  1117.             
  1118.         case telTermOpenMsg :
  1119.             HandleTermOpenMsg (termHand, mtype, value);
  1120.             break;
  1121.             
  1122.         case telTermCloseMsg :
  1123.             HandleTermCloseMsg (termHand, mtype, value);
  1124.             break;
  1125.             
  1126.         case telTermResetMsg :
  1127.             HandleTermResetMsg (termHand, mtype, value);
  1128.             break;
  1129.             
  1130.         case telTermErrorMsg :
  1131.             HandleTermErrorMsg (termHand, mtype, value);
  1132.             break;
  1133.             
  1134.         case telTermIndHSStateChgMsg :
  1135.             HandleTermIndHSStateChgMsg (termHand, mtype, value);
  1136.             break;
  1137.             
  1138.         case telTermIndHSConnectMsg :
  1139.             HandleTermIndHSConnectMsg (termHand, mtype, value);
  1140.             break;
  1141.             
  1142.         case telTermKeyImmMsg :
  1143.             HandleTermKeyImmMsg (termHand, mtype, value);
  1144.             break;
  1145.             
  1146.         case telTermVolStateMsg :
  1147.             HandleTermVolStateMsg (termHand, mtype, value);
  1148.             break;
  1149.             
  1150.         case telTermOtherMsg :
  1151.             HandleTermOtherMsg (termHand, mtype, value);
  1152.             break;
  1153.             
  1154.         default :
  1155.             PutCLine (gLogWindow, kErrorColor, "### Unknown termMsg : %08x", msg);
  1156.     }
  1157.     
  1158.     (void) SetA5 (oldA5);
  1159. }
  1160.  
  1161.  
  1162. OSErr    InstallTermHandler (TelWindowPtr telWindow)
  1163. {
  1164.     OSErr            errCode;
  1165.     TELHandle        termHand;
  1166.     
  1167.     termHand = telWindow->fTELHandle;
  1168.     
  1169.     errCode = TELTermMsgHand (termHand, telAllTermMsgs | telTermOtherMsg, gTermMsgHandlerUPP, SetCurrentA5());
  1170.     
  1171.     if (errCode != noErr)
  1172.         PutCLine (gLogWindow, kErrorColor, "### TELTermMsgHand fails : %d", errCode);
  1173.     
  1174.     return (errCode);
  1175. }
  1176.  
  1177.  
  1178. void    HandleTermHookMsg (TELHandle termHand, short mtype, short value)
  1179. {
  1180.     PutCLine (gLogWindow, kTermMsgColor, "::: telTermHookMsg (%08x) --> type = %d, value = %s", termHand, mtype, (value)?"telDeviceOffHook":"telDeviceOnHook");
  1181. }
  1182.  
  1183.  
  1184. void    HandleTermKeyMsg (TELHandle termHand, short mtype, short value)
  1185. {
  1186.     switch (mtype) {
  1187.         case telKeyPadPress :
  1188.             PutCLine (gLogWindow, kTermMsgColor, "::: telTermKeyMsg (%08x) --> %c", termHand, value);
  1189.             break;
  1190.             
  1191.         case telFeatureKeyPress :
  1192.             PutCLine (gLogWindow, kTermMsgColor, "::: telTermKeyMsg (%08x) --> %d", termHand, value);
  1193.             break;
  1194.             
  1195.         default :
  1196.             PutCLine (gLogWindow, kTermMsgColor, "::: telTermKeyMsg (%08x) --> ### Unknown type", termHand);
  1197.     }
  1198. }
  1199.  
  1200.  
  1201. void    HandleTermVolMsg (TELHandle termHand, short mtype, short value)
  1202. {
  1203.     PutCLine (gLogWindow, kTermMsgColor, "::: telTermVolMsg (%08x) --> spType = %d, level = %d", termHand, mtype, value);
  1204. }
  1205.  
  1206.  
  1207. void    HandleTermDispMsg (TELHandle termHand, short mtype, short value)
  1208. {
  1209.     PutCLine (gLogWindow, kTermMsgColor, "::: telTermDisplayMsg (%08x) --> dispType = %d, what = %d", termHand, mtype, value);
  1210. }
  1211.  
  1212.  
  1213. void    HandleTermEnableMsg (TELHandle termHand, short mtype, short value)
  1214. {
  1215.     PutCLine (gLogWindow, kTermMsgColor, "::: telTermEnableMsg (%08x) --> (reserved) type = %d, value = %d", termHand, mtype, value);
  1216. }
  1217.  
  1218.  
  1219. void    HandleTermOpenMsg (TELHandle termHand, short mtype, short value)
  1220. {
  1221.     PutCLine (gLogWindow, kTermMsgColor, "::: telTermOpenMsg (%08x) --> (reserved) type = %d, value = %d", termHand, mtype, value);
  1222. }
  1223.  
  1224.  
  1225. void    HandleTermCloseMsg (TELHandle termHand, short mtype, short value)
  1226. {
  1227.     PutCLine (gLogWindow, kTermMsgColor, "::: telTermCloseMsg (%08x) --> (reserved) type = %d, value = %d", termHand, mtype, value);
  1228. }
  1229.  
  1230.  
  1231. void    HandleTermResetMsg (TELHandle termHand, short mtype, short value)
  1232. {
  1233.     PutCLine (gLogWindow, kTermMsgColor, "::: telTermResetMsg (%08x) --> (reserved) type = %d, value = %d", termHand, mtype, value);
  1234. }
  1235.  
  1236.  
  1237. void    HandleTermErrorMsg (TELHandle termHand, short mtype, short value)
  1238. {
  1239.     PutCLine (gLogWindow, kTermMsgColor, "::: telTermErrorMsg (%08x) --> (reserved) type = %d, value = %d", termHand, mtype, value);
  1240. }
  1241.  
  1242.  
  1243. void    HandleTermIndHSStateChgMsg (TELHandle termHand, short mtype, short value)
  1244. {
  1245.     PutCLine (gLogWindow, kTermMsgColor, "::: telTermIndHSStateChgMsg (%08x) --> (reserved) type = %s, value = %s", termHand, (mtype)?"telIndHSConnected":"telIndHSDisconnected", (value)?"telIndHSOffHook":"telIndHSOnHook");
  1246. }
  1247.  
  1248.  
  1249. void    HandleTermIndHSConnectMsg (TELHandle termHand, short mtype, short value)
  1250. {
  1251.     PutCLine (gLogWindow, kTermMsgColor, "::: telTermIndHSConnectMsg (%08x) --> (reserved) type = %d, value = %s", termHand, mtype, (value)?"telIndHSConnected":"telIndHSDisconnected");
  1252. }
  1253.  
  1254.  
  1255. void    HandleTermKeyImmMsg (TELHandle termHand, short mtype, short value)
  1256. {
  1257.     switch (mtype) {
  1258.         case telKeyPadPress :
  1259. //            PutCLine (gLogWindow, kTermMsgColor, "::: telTermKeyImmMsg (%08x) --> %c", termHand, value);
  1260.             PutCLine (gLogWindow, kTermMsgColor, "::: telTermKeyImmMsg (%08x) --> type = telKeyPadPress, value = %c", termHand, value);
  1261.             break;
  1262.             
  1263.         case telFeatureKeyPress :
  1264. //            PutCLine (gLogWindow, kTermMsgColor, "::: telTermKeyImmMsg (%08x) --> %d", termHand, value);
  1265.             PutCLine (gLogWindow, kTermMsgColor, "::: telTermKeyImmMsg (%08x) --> type = telFeatureKeyPress, value = %d", termHand, value);
  1266.             break;
  1267.             
  1268.         default :
  1269.             PutCLine (gLogWindow, kTermMsgColor, "::: telTermKeyImmMsg (%08x) --> ### Unknown type", termHand);
  1270.     }
  1271. }
  1272.  
  1273.  
  1274. void    HandleTermVolStateMsg (TELHandle termHand, short mtype, short value)
  1275. {
  1276.     char *    typeStr;
  1277.     char *    valueStr;
  1278.     
  1279.     switch (mtype) {
  1280.         case telHandsetSpeakerVol :
  1281.             typeStr = "telHandsetSpeakerVol";
  1282.             break;
  1283.         case telHandsetMicVol :
  1284.             typeStr = "telHandsetMicVol";
  1285.             break;
  1286.         case telSpeakerphoneVol :
  1287.             typeStr = "telSpeakerphoneVol";
  1288.             break;
  1289.         case telSpeakerphoneMicVol :
  1290.             typeStr = "telSpeakerphoneMicVol";
  1291.             break;
  1292.         case telRingerVol :
  1293.             typeStr = "telRingerVol";
  1294.             break;
  1295.         case telBuiltinSPVol :
  1296.             typeStr = "telBuiltinSPVol";
  1297.             break;
  1298.         case telBuiltinSPMicVol :
  1299.             typeStr = "telBuiltinSPMicVol";
  1300.             break;
  1301.         default :
  1302.             typeStr = "### Unknown mtype";
  1303.             PutCLine (gLogWindow, kErrorColor, "### Unknown mtype : %d", mtype);
  1304.     }
  1305.  
  1306.     switch (value) {
  1307.         case telVolStateOff :
  1308.             valueStr = "telVolStateOff";
  1309.             break;
  1310.         case telVolStateOn :
  1311.             valueStr = "telVolStateOn";
  1312.             break;
  1313.         default :
  1314.             valueStr = "### Unknown value";
  1315.             PutCLine (gLogWindow, kErrorColor, "### Unknown value : %d", value);
  1316.     }
  1317.  
  1318.     PutCLine (gLogWindow, kTermMsgColor, "::: telTermVolStateMsg (%08x) --> (reserved) type = %s, value = %s", termHand, typeStr, valueStr);
  1319. }
  1320.  
  1321.  
  1322. void    HandleTermOtherMsg (TELHandle termHand, short mtype, short value)
  1323. {
  1324.     PutCLine (gLogWindow, kTermMsgColor, "::: telTermOtherMsg (%08x) --> (vendor defined) type = %d, value = %d", termHand, mtype, value);
  1325. }
  1326.  
  1327.  
  1328. void    DumpSelectedDNInfo (TelWindowPtr telWindow)
  1329. {
  1330.     short            count;
  1331.     Cell            tCell;
  1332.     DNWindowPtr        tDNWindow;
  1333.  
  1334.     SetPt (&tCell, 0, 0);
  1335.     while (LGetSelect (true, &tCell, telWindow->fDNList)) {
  1336.         tDNWindow = telWindow->fDNWindowList;
  1337.         count = 0;
  1338.         while (count++ < tCell.v)
  1339.             tDNWindow = tDNWindow->next;
  1340.  
  1341.         DumpDNInfo (tDNWindow->fDNHandle);
  1342.         if (! LNextCell (true, true, &tCell, telWindow->fDNList))
  1343.             break;
  1344.     }
  1345. }
  1346.  
  1347.  
  1348. void    DumpSelectedDNEvents (TelWindowPtr telWindow)
  1349. {
  1350.     short            count;
  1351.     Cell            tCell;
  1352.     DNWindowPtr        tDNWindow;
  1353.  
  1354.     SetPt (&tCell, 0, 0);
  1355.     while (LGetSelect (true, &tCell, telWindow->fDNList)) {
  1356.         tDNWindow = telWindow->fDNWindowList;
  1357.         count = 0;
  1358.         while (count++ < tCell.v)
  1359.             tDNWindow = tDNWindow->next;
  1360.  
  1361.         DumpDNEvents (tDNWindow->fDNHandle);
  1362.         if (! LNextCell (true, true, &tCell, telWindow->fDNList))
  1363.             break;
  1364.     }
  1365. }
  1366.  
  1367.  
  1368. void    ShowDNWindow (TelWindowPtr telWindow, short whichDN)
  1369. {
  1370.     short        count = 0;
  1371.     DNWindowPtr    tDNWindow = telWindow->fDNWindowList;
  1372.     
  1373.     while (count++ < whichDN)
  1374.         tDNWindow = tDNWindow->next;
  1375.         
  1376.     ShowWindow ((WindowPtr) tDNWindow);
  1377.     SelectWindow ((WindowPtr) tDNWindow);
  1378. }
  1379.  
  1380.  
  1381. void AdjustInternalDataStructures (TelWindowPtr telWindow)
  1382. {
  1383.     DNWindowPtr        dnWindow;
  1384.     CAWindowPtr        caWindow;
  1385.     
  1386.     if (telWindow)
  1387.     {
  1388.         dnWindow = telWindow->fDNWindowList;
  1389.         while (dnWindow) {
  1390.             caWindow = dnWindow->fCAWindowList;
  1391.             while (caWindow) {
  1392.                 caWindow->fCAHandle = nil;
  1393.                 caWindow = caWindow->next;
  1394.             }
  1395.             
  1396.             dnWindow->fDNHandle = nil;
  1397.             dnWindow = dnWindow->next;
  1398.         }
  1399.         
  1400. //        if (telWindow->fRPWindow)
  1401. //            telWindow->fRPWindow->fTELHandle = nil;
  1402.         
  1403. //        telWindow->fTELHandle = nil;        /* TEMPORARY */
  1404.     }
  1405. }
  1406.  
  1407.  
  1408. void    HandleChoose (TelWindowPtr telWindow)
  1409. {
  1410.     short        returnValue;
  1411.     TELHandle    termHand = telWindow->fTELHandle;
  1412.     Point         where;
  1413.     char         *chooseResult;
  1414.     Rect        windRect;
  1415.     OSErr        errCode;
  1416.     DNWindowPtr    dnWindow, tDNWindow;
  1417.     
  1418.     SetPt (&where, 40, 40);
  1419.     
  1420.     returnValue = TELChoose(&termHand, where, nil);
  1421.     
  1422.     switch (returnValue) {
  1423.         case telChooseDisaster :
  1424.             chooseResult = "telChooseDisaster";
  1425.             break;
  1426.             
  1427.         case telChooseFailed :
  1428.             chooseResult = "telChooseFailed";
  1429.             break;
  1430.             
  1431.         case telChooseAborted :
  1432.             chooseResult = "telChooseAborted";
  1433.             break;
  1434.             
  1435.         case telChooseOKMinor :
  1436.             chooseResult = "telChooseOKMinor";
  1437.             break;
  1438.             
  1439.         case telChooseOKMajor :
  1440.             chooseResult = "telChooseOKMajor";
  1441.             break;
  1442.             
  1443.         case telChooseCancel :
  1444.             chooseResult = "telChooseCancel";
  1445.             break;
  1446.             
  1447.         case telChooseOKTermChanged :
  1448.             if ((errCode = TELClrTermMsgHand (termHand, gTermMsgHandlerUPP)) != noErr)
  1449.                 PutCLine (gLogWindow, kErrorColor, "### TELClrTermMsgHand fails : %d", errCode);
  1450.  
  1451.             chooseResult = "telChooseOKTermChanged";
  1452.             break;
  1453.  
  1454.         default :
  1455.             chooseResult = "### unknown";
  1456.     }
  1457.  
  1458.     PutLine (gLogWindow, "TELChoose returns : %s", chooseResult);
  1459.  
  1460.     if ((termHand != telWindow->fTELHandle) || (returnValue == telChooseOKTermChanged)) {
  1461.         
  1462.         windRect = (**((WindowPeek) gTelWindow)->contRgn).rgnBBox;
  1463.         
  1464.         AdjustInternalDataStructures (gTelWindow);
  1465.         DisposeTelWindow (gTelWindow);
  1466.         gTelWindow = nil;
  1467.         
  1468.         (void) CreateTelWindow (&gTelWindow, &windRect, termHand);
  1469.     }
  1470.     else if ((returnValue == telChooseOKMajor) || (returnValue == telChooseOKMinor)) {
  1471.         dnWindow = telWindow->fDNWindowList;
  1472.         while (tDNWindow = dnWindow) {
  1473.             dnWindow = dnWindow->next;
  1474.             SetControlTitle (tDNWindow->fDirNumber, (*(tDNWindow->fDNHandle))->dn);        /* TEMPORARY */
  1475.         }
  1476.     }
  1477. }
  1478.  
  1479.  
  1480. short    GetConfigString (char * config)
  1481. {
  1482.     short        itemType;
  1483.     Handle        itemHand;
  1484.     Rect        itemRect;
  1485.     short        itemHit;
  1486.     DialogPtr    theDialog;
  1487.     
  1488.     if ((theDialog = GetNewDialog (rGetConfigDLOG, nil, (WindowPtr)(-1L))) != nil) {
  1489.  
  1490.         GetDItem (theDialog, kGetConfigDefault, &itemType, &itemHand, &itemRect);
  1491.         SetDItem (theDialog, kGetConfigDefault, itemType, (Handle) gDrawDefaultUPP, &itemRect);
  1492.  
  1493.         GetDItem (theDialog, kGetConfigConfig, &itemType, &itemHand, &itemRect);
  1494.         setitext (itemHand, config);
  1495.  
  1496.         ShowWindow (theDialog);
  1497.         
  1498.         ModalDialog (nil, &itemHit);
  1499.         
  1500.         if (itemHit == ok) {
  1501.             GetDItem (theDialog, kGetConfigConfig, &itemType, &itemHand, &itemRect);
  1502.             getitext (itemHand, config);
  1503.         }
  1504.         
  1505.         DisposeDialog (theDialog);
  1506.     }
  1507.     else
  1508.         itemHit = -1;
  1509.     
  1510.     return (itemHit);
  1511. }
  1512.  
  1513.  
  1514. void    HandleConfig (TelWindowPtr telWindow)
  1515. {
  1516.     OSErr        errCode;
  1517.     Ptr            config;
  1518.     short        itemHit;
  1519.     Rect        windRect;
  1520.     TELHandle    termHand = telWindow->fTELHandle;
  1521.     Str255        oldConfig, newConfig;
  1522.     
  1523.     if ((config = TELGetConfig (termHand)) != nil)
  1524.     {
  1525.         strcpy ((char *) oldConfig, (char *) config);
  1526.         strcpy ((char *) newConfig, (char *) config);        // Put into a slightly bigger buffer (Str255)
  1527.         DisposPtr (config);
  1528.         
  1529.         if ((itemHit = GetConfigString ((char *) newConfig)) == ok) {
  1530.         
  1531.             if ((errCode = TELSetConfig (termHand, (char *) newConfig)) == noErr) {
  1532.                 PutLine (gLogWindow, "TELSetConfig : %s", newConfig);
  1533.                 
  1534.                 if ((config = TELGetConfig (termHand)) != nil)
  1535.                 {
  1536.                     if (strcmp ((char *) oldConfig, (char *) config) != 0)
  1537.                     {
  1538.                         windRect = (**((WindowPeek) gTelWindow)->contRgn).rgnBBox;
  1539.                         
  1540.                         AdjustInternalDataStructures (gTelWindow);
  1541.                         DisposeTelWindow (gTelWindow);
  1542.  
  1543.                         if ((errCode = TELClrTermMsgHand (termHand, gTermMsgHandlerUPP)) != noErr)
  1544.                             PutCLine (gLogWindow, kErrorColor, "### TELClrTermMsgHand failed : %d", errCode);
  1545.                             
  1546.                         if ((errCode = TELCloseTerm (termHand)) != noErr)
  1547.                             PutCLine (gLogWindow, kErrorColor, "### TELCloseTerm fails : %d", errCode);
  1548.  
  1549. //                        if ((errCode = TELClrTermMsgHand (termHand, gTermMsgHandlerUPP)) != noErr)                /* TEMPORARY */
  1550. //                            PutCLine (gLogWindow, kErrorColor, "### TELClrTermMsgHand failed : %d", errCode);    /* TEMPORARY */
  1551.                             
  1552.                         gTelWindow = nil;
  1553.                         
  1554.                         (void) CreateTelWindow (&gTelWindow, &windRect, termHand);
  1555.                     }
  1556.                     
  1557.                     DisposPtr (config);
  1558.                 }
  1559.                 else
  1560.                     PutLine (gLogWindow, "### TELGetConfig returns nil");
  1561.             }
  1562.             else
  1563.                 PutLine (gLogWindow, "### TELSetConfig fails : %d", errCode);
  1564.         }
  1565.     } 
  1566.     else
  1567.         PutLine (gLogWindow, "### TELGetConfig returns nil");
  1568. }
  1569.  
  1570.  
  1571. void    HandleSelect (TelWindowPtr telWindow, short modifiers)
  1572. {
  1573.     Cell        tCell;
  1574.     short        count = 0;
  1575.     DNWindowPtr    tDNWindow = telWindow->fDNWindowList;
  1576.     OSErr        errCode;
  1577.     Boolean        select = (modifiers ? false : true);
  1578.  
  1579.     SetPt (&tCell, 0, 0);
  1580.     while (LGetSelect (true, &tCell, telWindow->fDNList)) {
  1581.     
  1582.         while (count++ < tCell.v)
  1583.             tDNWindow = tDNWindow->next;
  1584.         
  1585.         errCode = TELDNSelect (tDNWindow->fDNHandle, select);
  1586.         if (errCode == noErr)
  1587.             PutLine (gLogWindow, "TELDNSelect (%08x) : %s", tDNWindow->fDNHandle, (select?"selected":"deselected"));
  1588.         else
  1589.             PutCLine (gLogWindow, kErrorColor, "### TELDNSelect fails : %d", errCode);
  1590.         
  1591.         if (! LNextCell (true, true, &tCell, telWindow->fDNList))
  1592.             break;
  1593.     }
  1594. }
  1595.  
  1596.  
  1597. //void    HandleRP (TelWindowPtr telWindow, short modifiers)
  1598. //{
  1599. //    if (telWindow->fRPWindow) {
  1600. //        
  1601. //        if (modifiers)
  1602. //            SwitchToNew (telWindow->fRPWindow);
  1603. //        else
  1604. //            SwitchToOld (telWindow->fRPWindow);
  1605. //        
  1606. //        ShowWindow ((WindowPtr) telWindow->fRPWindow);
  1607. //        SelectWindow ((WindowPtr) telWindow->fRPWindow);
  1608. //    }
  1609. //}
  1610.  
  1611.  
  1612. OSErr    CreateFeatureList (TelWindowPtr telWindow)
  1613. {
  1614.     OSErr            errCode = noErr;
  1615.     FeatureListPtr    theList = nil;
  1616.     MenuHandle        theMenu = GetMenu (rFeatureMenu);
  1617.     short            item = 1;
  1618.     
  1619.     errCode = TELOtherFeatureList (telWindow->fTELHandle, &theList);
  1620.     if (errCode != noErr)
  1621.         PutCLine (gLogWindow, kErrorColor, "### TELOtherFeatureList fails : %d", errCode);
  1622.     else {
  1623.         if (telWindow->fFeatureList = theList)
  1624.         {
  1625.             while (theList)
  1626.             {
  1627.                 AppendMenu (theMenu, "\pX");
  1628.                 SetItem (theMenu, item, theList->featureName); 
  1629.                 theList = theList->nextFeature;
  1630.                 ++item;
  1631.             }
  1632.         }
  1633.         else
  1634.             PutLine (gLogWindow, "No other features were found");
  1635.     }
  1636.     
  1637.     return (errCode);
  1638. }
  1639.  
  1640.  
  1641. void    HandleFeatureMenu (TelWindowPtr telWindow, short menuID, short menuItem, short modifiers)
  1642. {
  1643. #pragma unused (menuID, modifiers)
  1644.     
  1645.     OSErr            errCode = noErr;
  1646.     Handle            tHandle = nil;
  1647.     FeatureListPtr    theList = telWindow->fFeatureList;
  1648.     short            index = 1;
  1649.     DNWindowPtr        dnWindow;
  1650.     
  1651.     while (theList)
  1652.     {
  1653.         if (index == menuItem)
  1654.             break;
  1655.         
  1656.         ++index;
  1657.         theList = theList->nextFeature;
  1658.     }
  1659.     
  1660.     if (index == menuItem)
  1661.     {
  1662.         switch (theList->handleType) {
  1663.             case 0 :
  1664.                 tHandle = (Handle) telWindow->fTELHandle;
  1665.                 break;
  1666.                 
  1667.             case 1 :
  1668.                 dnWindow = GetFirstSelectedDNWindow (telWindow);
  1669.                 tHandle = (Handle) dnWindow->fDNHandle;
  1670.                 break;
  1671.             
  1672.             case 2 :                
  1673.                 tHandle = (Handle) GetAnyCA (telWindow);
  1674.                 
  1675.                 break;
  1676.         }
  1677.                 
  1678.         if (tHandle) {
  1679.             errCode = TELOtherFeatureImplement (telWindow->fTELHandle, tHandle, theList->featureID);
  1680.  
  1681.             if (errCode == noErr)
  1682.                 PutLine (gLogWindow, "TELOtherFeatureImplement (%08x)", tHandle);
  1683.             else {
  1684.                 PutCLine (gLogWindow, kErrorColor, "### TELOtherFeatureImplement fails : %d", errCode);
  1685.             }
  1686.         }
  1687.     }
  1688.     else
  1689.         PutCLine (gLogWindow, kErrorColor, "### Can't find feature in list");
  1690. }
  1691.  
  1692.  
  1693. DNWindowPtr    GetFirstSelectedDNWindow (TelWindowPtr telWindow)
  1694. {
  1695.     short                count;
  1696.     Cell                tCell;
  1697.     DNWindowPtr            tDNWindow = nil;
  1698.     
  1699.     SetPt (&tCell, 0, 0);
  1700.     if (LGetSelect (true, &tCell, telWindow->fDNList)) {
  1701.         tDNWindow = telWindow->fDNWindowList;
  1702.         count = 0;
  1703.         while (count++ < tCell.v)
  1704.             tDNWindow = tDNWindow->next;
  1705.     }
  1706.     else
  1707.         PutCLine (gLogWindow, kErrorColor, "### No DN is selected in telWindow");
  1708.  
  1709.     return (tDNWindow);
  1710. }
  1711.  
  1712.  
  1713. void    PrepareGetAnyCADLOGUserItems (DialogPtr theDialog, TelWindowPtr telWindow)
  1714. {
  1715.     short        itemType;
  1716.     Handle        item;
  1717.     Rect        box;
  1718.     CursHandle     watch = GetCursor(watchCursor);
  1719.     
  1720.     if (watch != nil)
  1721.         SetCursor (*watch);
  1722.     
  1723.     GetDItem (theDialog, kGetAnyCABox1, &itemType, &item, &box);
  1724.     SetDItem (theDialog, kGetAnyCABox1, itemType, (Handle) gDrawBoxUPP, &box);
  1725.     
  1726.     GetDItem (theDialog, kGetAnyCADefault, &itemType, &item, &box);
  1727.     SetDItem (theDialog, kGetAnyCADefault, itemType, (Handle) gDrawDefaultUPP, &box);
  1728.     
  1729.     BuildAnyCAMenu (GetPopupMHandle (theDialog, kGetAnyCAPopup), telWindow);
  1730.     SetPopupValue (theDialog, kGetAnyCAPopup, 1);
  1731.  
  1732.     if (watch != nil)
  1733.         ReleaseResource ((Handle) watch);
  1734.     
  1735.     SetCursor (&qd.arrow);
  1736. }
  1737.  
  1738.  
  1739. TELCAHandle    GetAnyCA (TelWindowPtr telWindow)
  1740. {
  1741.     TELCAHandle    caHand = nil;
  1742.     DialogPtr    theDialog;
  1743.     short        itemHit;
  1744.     
  1745.     theDialog = GetNewDialog (rGetAnyCADLOG, nil, (WindowPtr)(-1L));
  1746.     if (theDialog == nil) {
  1747.         AlertUser ("\pUnable to get a DLOG resource !", ResError());
  1748.         return (nil);
  1749.     }
  1750.     
  1751.     PrepareGetAnyCADLOGUserItems (theDialog, telWindow);
  1752.     
  1753.     ShowWindow (theDialog);
  1754.     
  1755.     ModalDialog (gStandardFilterUPP, &itemHit);    
  1756.         
  1757.     HideWindow (theDialog);
  1758.     
  1759.     switch (itemHit) {
  1760.         case ok :
  1761.             caHand = GetNthCAFromTelList (GetPopupValue (theDialog, kGetAnyCAPopup), telWindow);
  1762.                 
  1763.             break;
  1764.         
  1765.         default :
  1766.             caHand = nil;
  1767.  
  1768.             PutCLine (gLogWindow, kErrorColor, "### User clicked Cancel");        /* TEMPORARY */
  1769.     }
  1770.     
  1771.     DisposDialog (theDialog);
  1772.     
  1773.     return (caHand);
  1774. }
  1775.  
  1776.  
  1777. void    BuildAnyCAMenu (MenuHandle theMenu, TelWindowPtr telWindow)
  1778. {
  1779.     DNWindowPtr     dnWindow;
  1780.     CAWindowPtr        caWindow;
  1781.     ListHandle        theList;
  1782.     Str255            caString;
  1783.     short            length, item = 1;
  1784.     Cell            tCell;
  1785.     
  1786.     dnWindow = telWindow->fDNWindowList;
  1787.     
  1788.     while (dnWindow)
  1789.     {
  1790.         theList = dnWindow->fCAList;
  1791.         caWindow = dnWindow->fCAWindowList;
  1792.         
  1793.         SetPt (&tCell, 0, 0);
  1794.         while (caWindow) {
  1795.             length = 0xFF;
  1796.             LGetCell (caString+1, &length, tCell, theList);
  1797.             caString[0] = length;
  1798.             AppendMenu (theMenu, "\pX");
  1799.             SetItem (theMenu, item, caString);
  1800.             
  1801.             caWindow = caWindow->next;
  1802.             ++tCell.v; ++item;
  1803.         }
  1804.         
  1805.         dnWindow = dnWindow->next;
  1806.     }
  1807. }
  1808.  
  1809.  
  1810. TELCAHandle    GetNthCAFromTelList (short n, TelWindowPtr telWindow)
  1811. {
  1812.     DNWindowPtr     dnWindow;
  1813.     CAWindowPtr        caWindow;
  1814.     short            index = 0;
  1815.     TELCAHandle        caHand = nil;
  1816.     
  1817.     dnWindow = telWindow->fDNWindowList;
  1818.  
  1819.     if (n)
  1820.     {
  1821.         while (dnWindow)
  1822.         {
  1823.             caWindow = dnWindow->fCAWindowList;
  1824.             
  1825.             while (caWindow) {                                
  1826.                 if (++index == n)
  1827.                     return (caWindow->fCAHandle);
  1828.                 
  1829.                 caWindow = caWindow->next;
  1830.             }
  1831.             
  1832.             dnWindow = dnWindow->next;
  1833.         }
  1834.     }
  1835.     
  1836.     return (caHand);
  1837. }
  1838.  
  1839.  
  1840. void    PrepareGetAnyDNDLOGUserItems (DialogPtr theDialog, TelWindowPtr telWindow)
  1841. {
  1842.     short        itemType;
  1843.     Handle        item;
  1844.     Rect        box;
  1845.     CursHandle     watch = GetCursor(watchCursor);
  1846.     
  1847.     if (watch != nil)
  1848.         SetCursor (*watch);
  1849.     
  1850.     GetDItem (theDialog, kGetAnyDNBox1, &itemType, &item, &box);
  1851.     SetDItem (theDialog, kGetAnyDNBox1, itemType, (Handle) gDrawBoxUPP, &box);
  1852.     
  1853.     GetDItem (theDialog, kGetAnyDNDefault, &itemType, &item, &box);
  1854.     SetDItem (theDialog, kGetAnyDNDefault, itemType, (Handle) gDrawDefaultUPP, &box);
  1855.     
  1856.     BuildAnyDNMenu (GetPopupMHandle (theDialog, kGetAnyDNPopup), telWindow);
  1857.     SetPopupValue (theDialog, kGetAnyDNPopup, 1);
  1858.  
  1859.     if (watch != nil)
  1860.         ReleaseResource ((Handle) watch);
  1861.     
  1862.     SetCursor (&qd.arrow);
  1863. }
  1864.  
  1865.  
  1866. TELDNHandle    GetAnyDN (TelWindowPtr telWindow)
  1867. {
  1868. //    TELHandle        termHand;
  1869.     Boolean            physical = false;  //false means both logical & physical DNs
  1870.     short            numOfDNs = 0;
  1871.     TELDNHandle        dnHand = nil;
  1872.     DialogPtr        theDialog;
  1873.     short            itemHit;
  1874.  
  1875. //    termHand = telWindow->fTELHandle;
  1876. //    numOfDNs = TELCountDNs (termHand, telAllDNs, physical);
  1877.  
  1878.     if ((numOfDNs = TELCountDNs (telWindow->fTELHandle, telAllDNs, physical)) < 0)
  1879.         PutCLine (gLogWindow, kErrorColor, "### TELCountDNs failed : %d", numOfDNs);
  1880.     else {
  1881.         if (numOfDNs == 1)
  1882.             dnHand = GetNthDNFromTelList (1, telWindow);
  1883.         else {
  1884.             theDialog = GetNewDialog (rGetAnyDNDLOG, nil, (WindowPtr)(-1L));
  1885.             if (theDialog == nil) {
  1886.                 AlertUser ("\pUnable to get a DLOG resource !", ResError());
  1887.                 return (nil);
  1888.             }
  1889.             
  1890.             PrepareGetAnyDNDLOGUserItems (theDialog, telWindow);
  1891.             
  1892.             ShowWindow (theDialog);
  1893.             
  1894.             ModalDialog (gStandardFilterUPP, &itemHit);    
  1895.                 
  1896.             HideWindow (theDialog);
  1897.             
  1898.             switch (itemHit) {
  1899.                 case ok :
  1900.                     dnHand = GetNthDNFromTelList (GetPopupValue (theDialog, kGetAnyDNPopup), telWindow);
  1901.                     break;
  1902.                 
  1903.                 default :
  1904.                     dnHand = nil;
  1905.             }        
  1906.             DisposDialog (theDialog);
  1907.         }
  1908.     }
  1909.     return (dnHand);
  1910. }
  1911.  
  1912.  
  1913. void    BuildAnyDNMenu (MenuHandle theMenu, TelWindowPtr telWindow)
  1914. {
  1915.     DNWindowPtr     dnWindow;
  1916.     ListHandle        theList;
  1917.     Str255            dnString;
  1918.     short            length, item = 1;
  1919.     Cell            tCell;
  1920.     
  1921.     theList = telWindow->fDNList;
  1922.     dnWindow = telWindow->fDNWindowList;
  1923.     
  1924.     SetPt (&tCell, 0, 0);
  1925.     while (dnWindow) {
  1926.         length = 0xFF;
  1927.         LGetCell (dnString+1, &length, tCell, theList);
  1928.         dnString[0] = length;
  1929.         AppendMenu (theMenu, "\pX");
  1930.         SetItem (theMenu, item, dnString);
  1931.         
  1932.         dnWindow = dnWindow->next;
  1933.         ++tCell.v; ++item;
  1934.     }
  1935. }
  1936.  
  1937.  
  1938. TELDNHandle    GetNthDNFromTelList (short n, TelWindowPtr telWindow)
  1939. {
  1940.     DNWindowPtr     dnWindow;
  1941.     short            index = 0;
  1942.     TELDNHandle        dnHand = nil;
  1943.     
  1944.     dnWindow = telWindow->fDNWindowList;
  1945.  
  1946.     if (n)
  1947.     {
  1948.         while (dnWindow)
  1949.         {
  1950.             if (++index == n)
  1951.                 return (dnWindow->fDNHandle);
  1952.                 
  1953.             dnWindow = dnWindow->next;
  1954.         }
  1955.     }
  1956.     
  1957.     return (dnHand);
  1958. }
  1959.  
  1960.  
  1961. TELCAHandle    GetActiveCA (TELHandle termHand)
  1962. {
  1963.     TelWindowPtr    telWindow;
  1964.     DNWindowPtr     dnWindow;
  1965.     CAWindowPtr        caWindow;
  1966.     TELCAHandle        caHand = nil;
  1967.     short            caState;
  1968.     OSErr            errCode;
  1969.     
  1970.     if (termHand)
  1971.     {
  1972.         if (telWindow = (TelWindowPtr) (*termHand)->userData)
  1973.         {
  1974.             dnWindow = telWindow->fDNWindowList;
  1975.     
  1976.             while (dnWindow)
  1977.             {
  1978.                 caWindow = dnWindow->fCAWindowList;
  1979.                 
  1980.                 while (caWindow) {    
  1981.                     caHand = caWindow->fCAHandle;
  1982.                     
  1983.                     if ((errCode = TELGetCAState(caHand, &caState)) != noErr)
  1984.                         PutCLine (gLogWindow, kErrorColor, "### TELGetCAState (%08x) fails : %d", caHand, errCode);
  1985.                     
  1986.                     if ((caState == telCAActiveState) || (caState == telCAConferencedState))
  1987.                         return (caHand);
  1988.                     
  1989.                     caWindow = caWindow->next;
  1990.                 }
  1991.                 
  1992.                 dnWindow = dnWindow->next;
  1993.             }
  1994.         }
  1995.     }
  1996.  
  1997.     PutCLine (gLogWindow, kErrorColor, "### No active CA currently available");
  1998.  
  1999.     return (nil);
  2000. }