tdialdlg.cpp

使用环境VC++ 6.0

    va_end(argList);

    m_editLog.SetSel(0xffffffff);
    m_editLog.ReplaceSel(szOutput);
}

void CtDialDlg::OnDestroy() 
{
    if( m_rgbValidLines )
    {
        delete[] m_rgbValidLines;
        m_rgbValidLines = 0;
    }

    if( m_pCall )
    {
        m_pCall->Drop();
        delete m_pCall;
        m_pCall = 0;
    }

    if( m_rgpLines )
    {
        DWORD   nLines = ::TfxGetNumLines();
        for( DWORD nLineID = 0; nLineID < nLines; nLineID++ )
        {
            if( m_rgpLines[nLineID] && m_rgpLines[nLineID]->GetHandle() )
            {
                m_rgpLines[nLineID]->Close();
                delete m_rgpLines[nLineID];
            }
        }

        delete[] m_rgpLines;
        m_rgpLines = 0;
    }

	CDialog::OnDestroy();
}

// Telephony handlers
void CtDialDlg::Dial(
    LPCSTR          pszPhoneNo, // = 0
    LINECALLPARAMS* pCallParams)// = 0
{
    ASSERT(m_rgpLines);
    ASSERT(!m_pCall);

    // Show the dialog
    CPhoneNoDlg dlg;
    dlg.m_pno.SetWholePhoneNo(pszPhoneNo);
    dlg.m_rgbShouldShowLines = m_rgbValidLines;

    if( dlg.DoModal() == IDOK )
    {
        // DONE: Use the dialog's address
        if( pCallParams )
        {
            pCallParams->dwAddressMode = LINEADDRESSMODE_ADDRESSID;
            pCallParams->dwAddressID = dlg.m_nAddressID;
        }

        if( (m_pCall = new CtCall(m_rgpLines[dlg.m_nLineID])) &&
            TPENDING(m_pCall->MakeCall(dlg.m_sDialable,
                                       dlg.m_pno.GetCountryCodeNum(),
                                       this, pCallParams)) )
        {
            LogStatus("Placing a call to '%s'...\r\n", dlg.m_pno.GetDisplayable());
            UpdateStatus();
        }
        else
        {
            delete m_pCall; m_pCall = 0;
            ::AfxMessageBox(IDS_CANT_MAKE_CALL);
        }
    }
}

void CtDialDlg::OnLineNewCall(
    CtLine* pLine,
    HCALL   hCall,
    DWORD   nAddressID,
    DWORD   nCallPriviledge)
{
    LogStatus("New call on line %d (address %d)\r\n", pLine->GetDeviceID(), nAddressID);

    // If we're not already handling a call,
    if( !m_pCall )
    {
        // we've got a new call
        m_pCall = new CtCall(pLine, hCall, this);

        // Check to see if call needs to be answered
        m_bCallUnanswered = FALSE;
        if( m_pCall )
        {
            CtCallStatus    cs;
            if( TSUCCEEDED(cs.GetCallStatus(m_pCall)) )
            {
                if( cs.GetCallFeatures() & LINECALLFEATURE_ANSWER )
                {
                    m_bCallUnanswered = TRUE;
                }
            }
        }

        UpdateStatus();
    }
}

void CtDialDlg::OnCallState(
    CtCall* pCall,
    DWORD   nCallState,
    DWORD   dwParam2,
    DWORD   nCallPriviledge)
{
    struct FlagMap { DWORD nFlag; LPCSTR pszFlag; };
    static FlagMap rgFlags[] =
    {
        {LINECALLSTATE_IDLE,        "idle"},
        {LINECALLSTATE_ACCEPTED,    "accepted"},
        {LINECALLSTATE_DIALTONE,    "dial tone detected"},
        {LINECALLSTATE_DIALING,     "dialing"},
        {LINECALLSTATE_RINGBACK,    "ring-back detected"},
        {LINECALLSTATE_BUSY,        "busy detected"},
        {LINECALLSTATE_SPECIALINFO, "error detected"},
        {LINECALLSTATE_CONNECTED,   "connected"},
        {LINECALLSTATE_PROCEEDING,  "proceeding"},
        {LINECALLSTATE_DISCONNECTED,"disconnected"},
    };

    for( int i = 0; i < DIM(rgFlags); i++ )
    {
        if( rgFlags[i].nFlag == nCallState )
        {
            LogStatus("Call %s.\r\n", rgFlags[i].pszFlag);
            break;
        }
    }

    switch( nCallState )
    {
    case LINECALLSTATE_DISCONNECTED:
        OnHangUp();
    break;

    case LINECALLSTATE_IDLE:
        delete m_pCall; m_pCall = 0;
    break;
    }

    UpdateStatus();
}

void CtDialDlg::OnCallReply(
    CtCall*     pCall,
    TREQUEST    nRequestID,
    TRESULT     nResult,
    DWORD       nRequestType)
{
    switch( nRequestType )
    {
    case CALLREQUEST_MAKECALL:
        if( TSUCCEEDED(nResult) )
        {
            LogStatus("Call placed.\r\n");
        }
        else
        {
            delete m_pCall; m_pCall = 0;
            LogStatus("Call cannot be placed.\r\n");
        }
    break;

    case CALLREQUEST_DROP:
        if( TSUCCEEDED(nResult) )
        {
            LogStatus("Call dropped.\r\n");
        }
        else
        {
            LogStatus("Call cannot be dropped.\r\n");
        }
    break;

    case CALLREQUEST_ANSWER:
        if( TSUCCEEDED(nResult) )
        {
            LogStatus("Call answered.\r\n");
        }
        else
        {
            LogStatus("Call cannot be answered.\r\n");
        }
    break;
    }

    UpdateStatus();
}

void CtDialDlg::OnLineClose(CtLine* pLine)
{
    LogStatus("Line %d closed.\r\n", pLine->GetDeviceID());

    if( m_pCall )
    {
        delete m_pCall; m_pCall = 0;
    }

    DWORD   nLineID = pLine->GetDeviceID();
    delete m_rgpLines[nLineID];
    m_rgpLines[nLineID] = 0;
}

// DONE
// Caller responsible for setting flags (if they are other than zero)
// and calling delete[] on result when buffer is no longer needed.
LINECALLPARAMS* AllocateCallParams(
    LPCSTR pszAddress = 0,
    LPCSTR pszCalledParty = 0,
    LPCSTR pszComment = 0)
{
    // Calculate LINECALLPARAMS sizes
    size_t  cbAddress     = (pszAddress && *pszAddress ? strlen(pszAddress) + 1 : 0);
    size_t  cbCalledParty = (pszCalledParty && *pszCalledParty ? strlen(pszCalledParty) + 1 : 0);
    size_t  cbComment     = (pszComment && *pszComment ? strlen(pszComment) + 1 : 0);
    size_t  cbCallParams  = sizeof(LINECALLPARAMS) + cbAddress + cbCalledParty + cbComment;

    // Allocate LINECALLPARAMS structure
    LINECALLPARAMS* pCallParams = (LINECALLPARAMS*)(new BYTE[cbCallParams]);
    if( pCallParams )
    {
        ZeroMemory(pCallParams, cbCallParams);
        pCallParams->dwTotalSize = cbCallParams;

        // Fill in a LINECALLPARAMS structure

        // pszAddress
        pCallParams->dwDisplayableAddressSize = cbAddress;
        if( cbAddress )
        {
            pCallParams->dwDisplayableAddressOffset = sizeof(LINECALLPARAMS);
            char*   psz = (char*)((BYTE*)pCallParams + pCallParams->dwDisplayableAddressOffset);
            strcpy(psz, pszAddress);
        }
        else
        {
            pCallParams->dwDisplayableAddressOffset = 0;
        }

        // pszCalledParty
        pCallParams->dwCalledPartySize = cbCalledParty;
        if( cbCalledParty )
        {
            pCallParams->dwCalledPartyOffset = sizeof(LINECALLPARAMS) + cbAddress;
            char*   psz = (char*)((BYTE*)pCallParams + pCallParams->dwCalledPartyOffset);
            strcpy(psz, pszCalledParty);
        }
        else
        {
            pCallParams->dwCalledPartyOffset = 0;
        }

        // pszComment
        pCallParams->dwCommentSize = cbComment;
        if( cbComment )
        {
            pCallParams->dwCommentOffset = sizeof(LINECALLPARAMS) + cbAddress + cbCalledParty;
            char*   psz = (char*)((BYTE*)pCallParams + pCallParams->dwCommentOffset);
            strcpy(psz, pszComment);
        }
        else
        {
            pCallParams->dwCommentOffset = 0;
        }
    }

    return pCallParams;
}

// DONE
void CtDialDlg::OnLineRequest(DWORD nRequestMode, HWND hRequestWnd, TREQUEST nRequestID)
{
    ASSERT(nRequestMode == LINEREQUESTMODE_MAKECALL);

    LINEREQMAKECALL lmc;
    if( TSUCCEEDED(::TfxGetMakeCallRequest(&lmc)) )
    {
        UpdateData(FALSE);

        m_editLog.SetWindowText("");
        LogStatus("Request to call");
        if( lmc.szCalledParty[0] )
        {
            LogStatus(" '%s'", lmc.szCalledParty);
        }

        if( lmc.szAppName[0] )
        {
            LogStatus(" by '%s'", lmc.szAppName);
        }

        if( lmc.szComment[0] )
        {
            LogStatus(": '%s'", lmc.szComment);
        }

        LogStatus("...\r\n");
        UpdateStatus();

        // TAPI starts us minimized
        ShowWindow(SW_RESTORE);
        SetForegroundWindow();

        // Fill in a LINECALLPARAMS structure
        LINECALLPARAMS* pCallParams = AllocateCallParams(lmc.szDestAddress, lmc.szCalledParty, lmc.szComment);
        if( pCallParams )
        {
            pCallParams->dwBearerMode = LINEBEARERMODE_VOICE;
            pCallParams->dwMediaMode = LINEMEDIAMODE_INTERACTIVEVOICE;
        }

        Dial(lmc.szDestAddress, pCallParams);
        delete[] pCallParams;
    }
}