home *** CD-ROM | disk | FTP | other *** search
/ Network Support Encyclopedia 96-1 / novell-nsepro-1996-1-cd2.iso / download / netware / kvfon3.exe / PHONEDLG.H < prev    next >
C/C++ Source or Header  |  1994-11-22  |  19KB  |  635 lines
  1. /****************************************************************************
  2. **    File:    PHONEDLG.H
  3. **
  4. **    Desc:    Include files for the dialpad program.
  5. **
  6. **    This file is an include file for the dialpad program.  It contains the
  7. **    dialog source code for the dial pad, along with all of its functionality.
  8. **
  9. **    It is written for OWL 2.0 with Borland C++ 4.x.  To compile this program,
  10. **    create a project in BC4.x, similar to the .IDE project file included.
  11. **
  12. **        DISCLAIMER
  13. **
  14. **    Novell, Inc. makes no representations or warranties with respect to
  15. **    any NetWare software, and specifically disclaims any express or
  16. **    implied warranties of merchantability, title, or fitness for a
  17. **    particular purpose.
  18. **
  19. **    You may use this sample code in your own programs.
  20. **
  21. **    Distribution of any NetWare software is forbidden without the
  22. **    express written consent of Novell, Inc.  Further, Novell reserves
  23. **    the right to discontinue distribution of any NetWare software.
  24. **
  25. **    Novell is not responsible for lost profits or revenue, loss of use
  26. **    of the software, loss of data, costs of re-creating lost data, the
  27. **    cost of any substitute equipment or program, or claims by any party
  28. **    other than you.  Novell strongly recommends a backup be made before
  29. **    any software is installed.   Technical support for this software
  30. **    may be provided at the discretion of Novell.
  31. **
  32. **    Programmers:
  33. **
  34. **        Ini    Who                        Firm
  35. **        -----------------------------------------------------------------------
  36. **        KVW    Kevin V White        Novell Developer Support.
  37. **
  38. **    History:
  39. **
  40. **        When        Who    What
  41. **        -----------------------------------------------------------------------
  42. **        11-2        KVW    First code release
  43. **        11-16        KVW     Added conference, transfer, hold, hangup connection
  44. **        11-22        KVW    Added Send Calls feature
  45. */
  46.  
  47. /****************************************************************************
  48. **    This is the dial pad dialog's class.
  49. */
  50. class TPhoneDlg:public TDialog
  51. {
  52.     public:
  53.         char numToDial[30];
  54.         short entryIndex;
  55.         DeviceID_t callerExt;
  56.         ACSHandle_t globalACSHandle;
  57.         CSTAEvent_t eventBuffer;
  58.         unsigned short eventBufferSize;
  59.         unsigned short numEvents;
  60.         DeviceID_t callee;
  61.         ConnectionID_t callID;
  62.         RetCode_t    rCode;
  63.         InvokeID_t    invokeID;
  64.  
  65.         TEdit *numberEntryWindow;
  66.         BOOL SendCallStatus;
  67.         BOOL ForwardStatus;
  68.  
  69.         TPhoneDlg(TWindow *parent,TResId resId,ACSHandle_t *acsHandle,
  70.             DeviceID_t *userExt);
  71.         void SetupWindow();
  72.         void CleanupWindow();
  73.         void CmDial1();
  74.         void CmDial2();
  75.         void CmDial3();
  76.         void CmDial4();
  77.         void CmDial5();
  78.         void CmDial6();
  79.         void CmDial7();
  80.         void CmDial8();
  81.         void CmDial9();
  82.         void CmDial0();
  83.         void CmDialNumber();
  84.         void CmHangupCall();
  85.         void CmHangupConn();
  86.         void CmHold();
  87.         void CmUnhold();
  88.         void CmHelp();
  89.         void CmClearEntry();
  90.         void CmConference();
  91.         void CmTransfer();
  92.         void CmSendCalls();
  93.         void CmForward();
  94.  
  95.     DECLARE_RESPONSE_TABLE(TPhoneDlg);
  96. };
  97.  
  98. /****************************************************************************
  99. **    this is how OWL adds message handling to the windows message loop
  100. */
  101. DEFINE_RESPONSE_TABLE1(TPhoneDlg,TDialog)
  102.     EV_COMMAND(IDC_1,CmDial1),
  103.     EV_COMMAND(IDC_2,CmDial2),
  104.     EV_COMMAND(IDC_3,CmDial3),
  105.     EV_COMMAND(IDC_4,CmDial4),
  106.     EV_COMMAND(IDC_5,CmDial5),
  107.     EV_COMMAND(IDC_6,CmDial6),
  108.     EV_COMMAND(IDC_7,CmDial7),
  109.     EV_COMMAND(IDC_8,CmDial8),
  110.     EV_COMMAND(IDC_9,CmDial9),
  111.     EV_COMMAND(IDC_10,CmDial0),
  112.     EV_COMMAND(IDC_DIAL,CmDialNumber),
  113.     EV_COMMAND(IDC_HANGUPCALL,CmHangupCall),
  114.     EV_COMMAND(IDC_HANGUPCONN,CmHangupConn),
  115.     EV_COMMAND(IDC_HOLD,CmHold),
  116.     EV_COMMAND(IDC_UNHOLD,CmUnhold),
  117.     EV_COMMAND(IDC_HELP,CmHelp),
  118.     EV_COMMAND(IDC_CLEARENTRY,CmClearEntry),
  119.     EV_COMMAND(IDC_CONFERENCE,CmConference),
  120.     EV_COMMAND(IDC_TRANSFER,CmTransfer),
  121.     EV_COMMAND(IDC_SENDCALLS,CmSendCalls),
  122.     EV_COMMAND(IDC_FORWARD,CmForward),
  123. END_RESPONSE_TABLE;
  124.  
  125. /****************************************************************************
  126. **    constructor for the dial pad dialog
  127. */
  128. TPhoneDlg::TPhoneDlg(TWindow *parent,TResId resId,ACSHandle_t *acsHandle,
  129.     DeviceID_t *userExt)
  130.     :TDialog(parent,resId),TWindow(parent)
  131. {
  132.     /*------------------------------------------------------------------------
  133.     **    callerExt is the user's extension
  134.     ** numToDial is a string built from the number the user dials
  135.     **    entryIndex is the position in the array for the next digit dialed
  136.     ** globalACSHandle is the acshandle we receive in the constructor
  137.     */
  138.     strcpy(callerExt,*userExt);
  139.     numToDial[0]=0;
  140.     entryIndex=0;
  141.     strcpy(callerExt,*userExt);
  142.     globalACSHandle=*acsHandle;
  143.     eventBufferSize=sizeof(CSTAEvent_t);
  144.     SendCallStatus=FALSE;
  145.     ForwardStatus=FALSE;
  146. }
  147.  
  148. /****************************************************************************
  149. ** SetupWindow is called when the dialog window is created
  150. */
  151. void TPhoneDlg::SetupWindow()
  152. {
  153.     /*------------------------------------------------------------------------
  154.     ** first, call the parent's SetupWindow
  155.     */
  156.     TDialog::SetupWindow();
  157.  
  158.     /*------------------------------------------------------------------------
  159.     ** create an alias to the text box in the dialog, as the alias will be
  160.     ** easier to enter text into and retrieve text from than the dialog
  161.     */
  162.     numberEntryWindow=new TEdit(this,IDC_NUMDISPLAY,30);
  163.     numberEntryWindow->Create();
  164. }
  165.  
  166. /****************************************************************************
  167. **    CleanupWindow is called when the window is destroyed.  We just use it to
  168. ** free the memory allocated to our TEdit alias in SetupWindow, then call
  169. **    the parent's CleanupWindow
  170. */
  171. void TPhoneDlg::CleanupWindow()
  172. {
  173.     delete numberEntryWindow;
  174.  
  175.     TDialog::CleanupWindow();
  176. }
  177.  
  178. /****************************************************************************
  179. **    these functinos are used when the user presses one of the buttons corres-
  180. **    ponding to the digits on the phone dial pad.  In each one, we want to store
  181. **    the digit the user enters, increment the index into the character array,
  182. **    and then redisplay the string in the text window.
  183. */
  184.  
  185. void TPhoneDlg::CmDial1()
  186. {
  187.     if(entryIndex<28)
  188.     {
  189.         numToDial[entryIndex++]='1';
  190.         numToDial[entryIndex]=0;
  191.         SetDlgItemText(IDC_NUMDISPLAY,numToDial);
  192.     }
  193. }
  194.  
  195. void TPhoneDlg::CmDial2()
  196. {
  197.     if(entryIndex<28)
  198.     {
  199.         numToDial[entryIndex++]='2';
  200.         numToDial[entryIndex]=0;
  201.         SetDlgItemText(IDC_NUMDISPLAY,numToDial);
  202.     }
  203. }
  204.  
  205. void TPhoneDlg::CmDial3()
  206. {
  207.     if(entryIndex<28)
  208.     {
  209.         numToDial[entryIndex++]='3';
  210.         numToDial[entryIndex]=0;
  211.         SetDlgItemText(IDC_NUMDISPLAY,numToDial);
  212.     }
  213. }
  214.  
  215. void TPhoneDlg::CmDial4()
  216. {
  217.     if(entryIndex<28)
  218.     {
  219.         numToDial[entryIndex++]='4';
  220.         numToDial[entryIndex]=0;
  221.         SetDlgItemText(IDC_NUMDISPLAY,numToDial);
  222.     }
  223. }
  224.  
  225. void TPhoneDlg::CmDial5()
  226. {
  227.     if(entryIndex<28)
  228.     {
  229.         numToDial[entryIndex++]='5';
  230.         numToDial[entryIndex]=0;
  231.         SetDlgItemText(IDC_NUMDISPLAY,numToDial);
  232.     }
  233. }
  234.  
  235. void TPhoneDlg::CmDial6()
  236. {
  237.     if(entryIndex<28)
  238.     {
  239.         numToDial[entryIndex++]='6';
  240.         numToDial[entryIndex]=0;
  241.         SetDlgItemText(IDC_NUMDISPLAY,numToDial);
  242.     }
  243. }
  244.  
  245. void TPhoneDlg::CmDial7()
  246. {
  247.     if(entryIndex<28)
  248.     {
  249.         numToDial[entryIndex++]='7';
  250.         numToDial[entryIndex]=0;
  251.         SetDlgItemText(IDC_NUMDISPLAY,numToDial);
  252.     }
  253. }
  254.  
  255. void TPhoneDlg::CmDial8()
  256. {
  257.     if(entryIndex<28)
  258.     {
  259.         numToDial[entryIndex++]='8';
  260.         numToDial[entryIndex]=0;
  261.         SetDlgItemText(IDC_NUMDISPLAY,numToDial);
  262.     }
  263. }
  264.  
  265. void TPhoneDlg::CmDial9()
  266. {
  267.     if(entryIndex<28)
  268.     {
  269.         numToDial[entryIndex++]='9';
  270.         numToDial[entryIndex]=0;
  271.         SetDlgItemText(IDC_NUMDISPLAY,numToDial);
  272.     }
  273. }
  274.  
  275. void TPhoneDlg::CmDial0()
  276. {
  277.     if(entryIndex<28)
  278.     {
  279.         numToDial[entryIndex++]='0';
  280.         numToDial[entryIndex]=0;
  281.         SetDlgItemText(IDC_NUMDISPLAY,numToDial);
  282.     }
  283. }
  284.  
  285. /****************************************************************************
  286. **    Here we dial the number the user has entered.
  287. */
  288. void TPhoneDlg::CmDialNumber()
  289. {
  290.     BOOL done=FALSE;
  291.  
  292.     /*------------------------------------------------------------------------
  293.     **    has the user actually pressed the digits to make a number to dial?
  294.     */
  295.     if(numToDial[0]!=0)
  296.     {
  297.         /*---------------------------------------------------------------------
  298.         **    get the number dialed, and make the call.
  299.         */
  300.         strcpy(callee,numToDial);
  301.         rCode=cstaMakeCall(globalACSHandle,invokeID,&callerExt,&callee,NULL);
  302.         /*---------------------------------------------------------------------
  303.         **    if MakeCall was successful, it will return the invokeID (above 0)
  304.         */
  305.         if(rCode>0)
  306.         {
  307.             /*------------------------------------------------------------------
  308.             **    We enter a poll loop, waiting for our event to confirm the makecall
  309.             */
  310.             while(!done)
  311.             {
  312.                 /*---------------------------------------------------------------
  313.                 **    first, very important, set the event buffer size to pass to
  314.                 ** getEventPoll.  If we don't reset it each time, it may be too
  315.                 ** small to get our event, and we will never get our make call
  316.                 ** confirmation event
  317.                 */
  318.                 eventBufferSize=sizeof(CSTAEvent_t);
  319.                 /*---------------------------------------------------------------
  320.                 **    get the event, and check its type
  321.                 */
  322.                 rCode=acsGetEventPoll(globalACSHandle,&eventBuffer,&eventBufferSize,
  323.                     NULL,&numEvents);
  324.                 if(rCode==ACSPOSITIVE_ACK)
  325.                 {
  326.                     if(eventBuffer.eventHeader.eventType==CSTA_MAKE_CALL_CONF)
  327.                     {
  328.                         /*---------------------------------------------------------
  329.                         **    if it's the right event type, the callID is stored in
  330.                         ** the confirmation event structure, which we will need to
  331.                         ** store so that the user can hangup on the call later.  Then,
  332.                         **    we'll enable the appropriate buttons.
  333.                         */
  334.                         callID=eventBuffer.event.cstaConfirmation.u.makeCall.newCall;
  335.                         ::EnableWindow(GetDlgItem(IDC_HANGUPCALL),1);
  336.                         ::EnableWindow(GetDlgItem(IDC_HANGUPCONN),1);
  337.                         ::EnableWindow(GetDlgItem(IDC_CONFERENCE),1);
  338.                         ::EnableWindow(GetDlgItem(IDC_TRANSFER),1);
  339.                         ::EnableWindow(GetDlgItem(IDC_HOLD),1);
  340.                         done=TRUE;
  341.                     }
  342.                 }
  343.                 else if(rCode==ACSERR_NOMESSAGE)
  344.                 {
  345.                     done=FALSE;
  346.                 }
  347.                 else
  348.                 {
  349.                     /*------------------------------------------------------------
  350.                     ** we can't get the event that the call was made successfully,
  351.                     **    so disable the appropriate buttons.
  352.                     */
  353.                     ::EnableWindow(GetDlgItem(IDC_HANGUPCONN),0);
  354.                     ::EnableWindow(GetDlgItem(IDC_CONFERENCE),0);
  355.                     ::EnableWindow(GetDlgItem(IDC_HANGUPCALL),0);
  356.                     ::EnableWindow(GetDlgItem(IDC_TRANSFER),0);
  357.                     ::EnableWindow(GetDlgItem(IDC_HOLD),0);
  358.                     done=TRUE;
  359.                 }
  360.             }
  361.         }
  362.         else
  363.         {
  364.             MessageBox("Unable to make call","TS Error!");
  365.         }
  366.     }
  367.  
  368. }
  369.  
  370. /****************************************************************************
  371. **    the user wants to hangup on a call.  Note that this will only work on a
  372. **    call that the user created, as we have to have a valid callID.  If that
  373. ** call was already cleared, well, we won't know about it, and will try to
  374. ** hang up on it anyway.  That won't gpf or anything, but it would be a nice
  375. ** enhancement to monitor the device, and clear the hangup button if the call
  376. ** happens to be cleared by the user, and not through this program.
  377. */
  378. void TPhoneDlg::CmHangupCall()
  379. {
  380.     /*------------------------------------------------------------------------
  381.     **    try to hangup on the call. we don't bother confirming that it worked,
  382.     ** as we don't really care.  We get an event, but don't check it's type.
  383.     **    As we're only getting solicited events, this should be fine.  One way
  384.     **    or the other, we're going to disable appropriate buttons afterwards.
  385.     */
  386.     rCode=cstaClearCall(globalACSHandle,invokeID,&callID,NULL);
  387.     if(rCode>0)
  388.     {
  389.         ::EnableWindow(GetDlgItem(IDC_HANGUPCALL),0);
  390.         ::EnableWindow(GetDlgItem(IDC_HANGUPCONN),0);
  391.         ::EnableWindow(GetDlgItem(IDC_CONFERENCE),0);
  392.         ::EnableWindow(GetDlgItem(IDC_HOLD),0);
  393.         ::EnableWindow(GetDlgItem(IDC_UNHOLD),0);
  394.         ::EnableWindow(GetDlgItem(IDC_TRANSFER),0);
  395.     }
  396.     eventBufferSize=sizeof(CSTAEvent_t);
  397.     rCode=acsGetEventBlock(globalACSHandle,&eventBuffer,&eventBufferSize,
  398.         NULL,&numEvents);
  399. }
  400.  
  401. void TPhoneDlg::CmHangupConn()
  402. {
  403.     /*------------------------------------------------------------------------
  404.     **    try to hangup the connection. we don't bother confirming that it worked,
  405.     ** as we don't really care.  We get an event, but don't check it's type.
  406.     **    As we're only getting solicited events, this should be fine.  One way
  407.     **    or the other, we're going to disable appropriate buttons afterwards.
  408.     */
  409.     rCode=cstaClearConnection(globalACSHandle,invokeID,&callID,NULL);
  410.     if(rCode>0)
  411.     {
  412.         ::EnableWindow(GetDlgItem(IDC_HANGUPCALL),0);
  413.         ::EnableWindow(GetDlgItem(IDC_HANGUPCONN),0);
  414.         ::EnableWindow(GetDlgItem(IDC_CONFERENCE),0);
  415.         ::EnableWindow(GetDlgItem(IDC_HOLD),0);
  416.         ::EnableWindow(GetDlgItem(IDC_UNHOLD),0);
  417.         ::EnableWindow(GetDlgItem(IDC_TRANSFER),0);
  418.     }
  419.     eventBufferSize=sizeof(CSTAEvent_t);
  420.     rCode=acsGetEventBlock(globalACSHandle,&eventBuffer,&eventBufferSize,
  421.         NULL,&numEvents);
  422. }
  423.  
  424. /*************************************************************************
  425. **    The user wants to put the call on hold
  426. */
  427. void TPhoneDlg::CmHold()
  428. {
  429.     /*---------------------------------------------------------------------
  430.     **    put the call on hold
  431.     */
  432.     rCode=cstaHoldCall(globalACSHandle,invokeID,&callID,FALSE,NULL);
  433.     if(rCode<=0)
  434.     {
  435.         return;
  436.     }
  437.     /*---------------------------------------------------------------------
  438.     **    get an event
  439.     */
  440.     eventBufferSize=sizeof(CSTAEvent_t);
  441.     rCode=acsGetEventBlock(globalACSHandle,&eventBuffer,&eventBufferSize,NULL,
  442.         &numEvents);
  443.     if(rCode==ACSPOSITIVE_ACK)
  444.     {
  445.         /*------------------------------------------------------------------
  446.         **    set or disable appropriate buttons
  447.         */
  448.         ::EnableWindow(GetDlgItem(IDC_UNHOLD),1);
  449.         ::EnableWindow(GetDlgItem(IDC_HOLD),0);
  450.         ::EnableWindow(GetDlgItem(IDC_CONFERENCE),0);
  451.         ::EnableWindow(GetDlgItem(IDC_TRANSFER),0);
  452.     }
  453.     return;
  454. }
  455.  
  456. /*************************************************************************
  457. **    pick the call up from on hold
  458. */
  459. void TPhoneDlg::CmUnhold()
  460. {
  461.     /*---------------------------------------------------------------------
  462.     **    pick up the call
  463.     */
  464.     rCode=cstaRetrieveCall(globalACSHandle,invokeID,&callID,NULL);
  465.     if(rCode<=0)
  466.     {
  467.         return;
  468.     }
  469.     /*---------------------------------------------------------------------
  470.     **    get an event
  471.     */
  472.     eventBufferSize=sizeof(CSTAEvent_t);
  473.     rCode=acsGetEventBlock(globalACSHandle,&eventBuffer,&eventBufferSize,NULL,
  474.         &numEvents);
  475.     if(rCode==ACSPOSITIVE_ACK)
  476.     {
  477.         /*------------------------------------------------------------------
  478.         **    enable and disable appropriate buttons
  479.         */
  480.         ::EnableWindow(GetDlgItem(IDC_HOLD),1);
  481.         ::EnableWindow(GetDlgItem(IDC_UNHOLD),0);
  482.         ::EnableWindow(GetDlgItem(IDC_TRANSFER),1);
  483.         ::EnableWindow(GetDlgItem(IDC_CONFERENCE),1);
  484.     }
  485.     return;
  486. }
  487.  
  488. /****************************************************************************
  489. **    the user presed help.  Display help as a simple dialog with text.  If this
  490. **    were a more complex program, it would be nice to have a normal windows
  491. ** help file to use.
  492. */
  493. void TPhoneDlg::CmHelp()
  494. {
  495.     MessageBox(
  496.     "KVPhone is used as a dialpad for your phone with "
  497.     "NetWare Telephony Services.\n\n"
  498.     "Use the mouse to dial a number, then select Dial. \n\n"
  499.     "When on a phone conversation that you have created, you may press:\n"
  500.     "-Hangup Call to clear the call\n "
  501.     "-Hangup Conn to clear just your connectiona\n"
  502.     "-Conference to conference in another extension\n"
  503.     "-Transfer to transfer to another extionsion\n"
  504.     "-Hold to put the call on hold\n"
  505.     "-UnHold picks a call up from on hold\n"
  506.     "-Clear to clear the number display box to enter a new number.\n"
  507.     "-Send Calls will send incoming calls to your voice mail.\n"
  508.     "-Forward will forward your calls to another number."
  509.     ,"KVPhone Help");
  510. }
  511.  
  512. /****************************************************************************
  513. **    this is called to clear the number and start entering a new number to dial
  514. */
  515. void TPhoneDlg::CmClearEntry()
  516. {
  517.     numToDial[0]=0;
  518.     entryIndex=0;
  519.     SetDlgItemText(IDC_NUMDISPLAY,numToDial);
  520. }
  521.  
  522. /*************************************************************************
  523. **    call the conference dialog to conference the call
  524. */
  525. void TPhoneDlg::CmConference()
  526. {
  527.     TConfDlg *confDlg=new TConfDlg(this,5,&globalACSHandle,&callerExt,&callID);
  528.     confDlg->Execute();
  529. }
  530.  
  531. /*************************************************************************
  532. **    call the transfer dialog to transfer the call to another extionsion
  533. */
  534. void TPhoneDlg::CmTransfer()
  535. {
  536.     TXferDlg *xferDlg=new TXferDlg(this,1,&globalACSHandle,&callerExt,&callID);
  537.     xferDlg->Execute();
  538. }
  539.  
  540. /*************************************************************************
  541. **    send the calls to the cover extension.  In order to do this, the
  542. **    extension cannot be a DCS extension.  In other words, it must be an
  543. **    actual extension on this pbx.
  544. */
  545. void TPhoneDlg::CmSendCalls()
  546. {
  547.     if(SendCallStatus)
  548.     {
  549.         SendCallStatus=FALSE;
  550.         rCode=cstaSetDoNotDisturb(globalACSHandle,invokeID,&callerExt,FALSE,NULL);
  551.         if(rCode>0)
  552.         {
  553.             eventBufferSize=sizeof(CSTAEvent_t);
  554.             rCode=acsGetEventBlock(globalACSHandle,&eventBuffer,&eventBufferSize,
  555.                 NULL,&numEvents);
  556.             if(rCode==ACSPOSITIVE_ACK)
  557.             {
  558.                 return;
  559.             }
  560.             else
  561.             {
  562.                 MessageBox("Event returned wrong","Send Calls");
  563.                 return;
  564.             }
  565.         }
  566.         else
  567.         {
  568.             MessageBox("Cannot Turn Off Send Calls","Send Calls Error");
  569.             return;
  570.         }
  571.     }
  572.     else
  573.     {
  574.         SendCallStatus=TRUE;
  575.         rCode=cstaSetDoNotDisturb(globalACSHandle,invokeID,&callerExt,TRUE,NULL);
  576.         if(rCode>0)
  577.         {
  578.             eventBufferSize=sizeof(CSTAEvent_t);
  579.             rCode=acsGetEventBlock(globalACSHandle,&eventBuffer,&eventBufferSize,
  580.                 NULL,&numEvents);
  581.             if(rCode==ACSPOSITIVE_ACK)
  582.             {
  583.                 return;
  584.             }
  585.             else
  586.             {
  587.                 MessageBox("Event returned wrong","Send Calls");
  588.                 return;
  589.             }
  590.         }
  591.         else
  592.         {
  593.             MessageBox("Cannot Turn On Send Calls","Send Calls Error");
  594.             return;
  595.         }
  596.     }
  597. }
  598.  
  599. /*************************************************************************
  600. **    call the forward dialog to forward the calls to another extionsion
  601. */
  602. void TPhoneDlg::CmForward()
  603. {
  604.     if(ForwardStatus==FALSE)
  605.     {
  606.         TForward *forwardDlg=new TForward(this,8,&globalACSHandle,&callerExt,
  607.             &ForwardStatus);
  608.         forwardDlg->Execute();
  609.     }
  610.     else
  611.     {
  612.         ForwardStatus=FALSE;
  613.         rCode=cstaSetForwarding(globalACSHandle,invokeID,&callerExt,
  614.             FWD_IMMEDIATE,FALSE,&callerExt,NULL);
  615.         if(rCode>0)
  616.         {
  617.             eventBufferSize=sizeof(CSTAEvent_t);
  618.             rCode=acsGetEventBlock(globalACSHandle,&eventBuffer,&eventBufferSize,
  619.                 NULL,&numEvents);
  620.             if(rCode==ACSPOSITIVE_ACK)
  621.             {
  622.             }
  623.             else
  624.             {
  625.                 MessageBox("Event returned wrong","Forward Calls");
  626.             }
  627.         }
  628.         else
  629.         {
  630.             MessageBox("Cannot Turn Off Forward Calls","Forward Calls Error");
  631.         }
  632.     }
  633. }
  634.  
  635.