able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/tapi/skywalker/apps/t3test/t3testd.cpp

2668 lines
57 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// t3testDlg.cpp : implementation file
//
#include "stdafx.h"
#include <control.h> // for IVideoWindow
#include "t3test.h"
#include "t3testD.h"
#include "calldlg.h"
#include "callnot.h"
#include "uuids.h"
#include "autoans.h"
#include "confdlg.h"
#include "ilsdlg.h"
#include "rate.h"
#ifdef _DEBUG
#ifndef _WIN64 // mfc 4.2's heap debugging features generate warnings on win64
#define new DEBUG_NEW
#endif
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
ITTAPI * gpTapi;
IConnectionPoint * gpCP;
HWND ghAddressesWnd;
HWND ghTerminalsWnd;
HWND ghMediaTypesWnd;
HWND ghCallsWnd;
HWND ghSelectedWnd;
HWND ghCreatedWnd;
HWND ghClassesWnd;
HWND ghListenWnd;
HTREEITEM ghAddressesRoot;
HTREEITEM ghTerminalsRoot;
HTREEITEM ghMediaTypesRoot;
HTREEITEM ghCallsRoot;
HTREEITEM ghSelectedRoot;
HTREEITEM ghCreatedRoot;
HTREEITEM ghClassesRoot;
HTREEITEM ghListenRoot;
#ifdef ENABLE_DIGIT_DETECTION_STUFF
CDigitDetectionNotification * gpDigitNotification;
#endif // ENABLE_DIGIT_DETECTION_STUFF
long gulAdvise;
BOOL gbUpdatingStuff = FALSE;
BOOL gfShuttingDown = FALSE;
DataPtrList gDataPtrList;
extern CT3testApp theApp;
const BSTR TAPIMEDIATYPE_String_Audio = L"{028ED8C2-DC7A-11D0-8ED3-00C04FB6809F}";
const BSTR TAPIMEDIATYPE_String_Video = L"{028ED8C4-DC7A-11D0-8ED3-00C04FB6809F}";
/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About
class CAboutDlg : public CDialog
{
public:
CAboutDlg();
// Dialog Data
//{{AFX_DATA(CAboutDlg)
enum { IDD = IDD_ABOUTBOX };
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CAboutDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
//{{AFX_MSG(CAboutDlg)
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
//{{AFX_DATA_INIT(CAboutDlg)
//}}AFX_DATA_INIT
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAboutDlg)
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
//{{AFX_MSG_MAP(CAboutDlg)
// No message handlers
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CT3testDlg dialog
CT3testDlg::CT3testDlg(CWnd* pParent /*=NULL*/)
: CDialog(CT3testDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CT3testDlg)
// NOTE: the ClassWizard will add member initialization here
//}}AFX_DATA_INIT
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
void CT3testDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CT3testDlg)
// NOTE: the ClassWizard will add DDX and DDV calls here
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CT3testDlg, CDialog)
//{{AFX_MSG_MAP(CT3testDlg)
ON_WM_SYSCOMMAND()
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_WM_DESTROY()
ON_NOTIFY(TVN_SELCHANGED, IDC_ADDRESSES, OnSelchangedAddresses)
ON_BN_CLICKED(IDC_ADDTERMINAL, OnAddterminal)
ON_BN_CLICKED(IDC_REMOVETERMINAL, OnRemoveterminal)
ON_BN_CLICKED(IDC_CREATECALL, OnCreatecall)
ON_BN_CLICKED(IDC_CONNECT, OnConnect)
ON_BN_CLICKED(IDC_DROP, OnDrop)
ON_BN_CLICKED(IDC_ANSWER, OnAnswer)
ON_BN_CLICKED(IDC_LISTEN, OnListen)
ON_NOTIFY(TVN_SELCHANGED, IDC_CALLS, OnSelchangedCalls)
ON_BN_CLICKED(IDC_RELEASE, OnRelease)
ON_BN_CLICKED(IDC_CREATE, OnCreateTerminal)
ON_BN_CLICKED(IDC_RELEASETERMINAL, OnReleaseterminal)
ON_BN_CLICKED(IDC_ADDCREATED, OnAddcreated)
ON_BN_CLICKED(IDC_ADDNULL, OnAddnull)
ON_BN_CLICKED(IDC_ADDTOLISTEN, OnAddtolisten)
ON_BN_CLICKED(IDC_LISTENALL, OnListenall)
ON_BN_CLICKED(IDC_CONFIGAUTOANSWER, OnConfigAutoAnswer)
ON_BN_CLICKED(IDC_ILS, OnILS)
ON_BN_CLICKED(IDC_RATE, OnRate)
ON_NOTIFY(TVN_SELCHANGED, IDC_MEDIATYPES, OnSelchangedMediatypes)
ON_NOTIFY(NM_RCLICK, IDC_SELECTEDTERMINALS, OnRclickSelectedterminals)
#ifdef ENABLE_DIGIT_DETECTION_STUFF
ON_COMMAND(ID_GENERATE, OnGenerate)
ON_COMMAND(ID_MODESUPPORTED, OnModesSupported)
ON_COMMAND(ID_MODESUPPORTED2, OnModesSupported2)
ON_COMMAND(ID_STARTDETECT, OnStartDetect)
ON_COMMAND(ID_STOPDETECT, OnStopDetect)
#endif // ENABLE_DIGIT_DETECTION_STUFF
ON_COMMAND(ID_PARK1, OnPark1)
ON_COMMAND(ID_PARK2, OnPark2)
ON_COMMAND(ID_HANDOFF1, OnHandoff1)
ON_COMMAND(ID_HANDOFF2, OnHandoff2)
ON_COMMAND(ID_UNPARK, OnUnpark)
ON_COMMAND(ID_PICKUP1, OnPickup1)
ON_COMMAND(ID_PICKUP2, OnPickup2)
ON_WM_CLOSE()
ON_MESSAGE(WM_USER+101, OnTapiEvent)
ON_NOTIFY(NM_RCLICK, IDC_CALLS, OnRclickCalls)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CT3testDlg message handlers
BOOL CT3testDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// IDM_ABOUTBOX must be in the system command range.
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);
CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
CString strAboutMenu;
strAboutMenu.LoadString(IDS_ABOUTBOX);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
}
}
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
HRESULT hr;
//
// coinit
//
hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
//hr = CoInitialize(NULL);
if (hr != S_OK)
{
MessageBox(L"CoInitialize failed", MB_OK);
return FALSE;
}
//
// create the tapi object
//
hr = CoCreateInstance(
CLSID_TAPI,
NULL,
CLSCTX_INPROC_SERVER,
IID_ITTAPI,
(LPVOID *)&gpTapi
);
if (hr != S_OK)
{
::MessageBox(NULL, L"CoCreateInstance on TAPI failed", NULL, MB_OK);
return TRUE;
}
//
// initialize tapi
//
hr = gpTapi->Initialize();
if (hr != S_OK)
{
::MessageBox(NULL, L"TAPI initialize failed", NULL, MB_OK);
gpTapi->Release();
return TRUE;
}
// Set the Event filter to only give us only the events we process
gpTapi->put_EventFilter(TE_CALLNOTIFICATION | \
TE_CALLSTATE | \
TE_CALLHUB | \
TE_CALLMEDIA | \
TE_TAPIOBJECT | \
TE_ADDRESS);
//
// intialize the tree controls
//
InitializeTrees();
//
// intialize the address tree control
//
InitializeAddressTree();
//
// register the main event interface
//
RegisterEventInterface();
//
// register for call notification for
// all addresses for outgoing calls
//
RegisterForCallNotifications();
return TRUE; // return TRUE unless you set the focus to a control
}
void CT3testDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
{
CAboutDlg dlgAbout;
dlgAbout.DoModal();
}
else
{
CDialog::OnSysCommand(nID, lParam);
}
}
// If you add a minimize button to your dialog, you will need the code below
// to draw the icon. For MFC applications using the document/view model,
// this is automatically done for you by the framework.
void CT3testDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}
// The system calls this to obtain the cursor to display while the user drags
// the minimized window.
HCURSOR CT3testDlg::OnQueryDragIcon()
{
return (HCURSOR) m_hIcon;
}
void CT3testDlg::OnFinalRelease()
{
// TODO: Add your specialized code here and/or call the base class
CDialog::OnFinalRelease();
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// SelectFirstItem
//
// selects the first item under the hroot node in hwnd.
// this is used to make sure that something is selected
// in the window at all times.
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::SelectFirstItem(
HWND hWnd,
HTREEITEM hRoot
)
{
HTREEITEM hChild;
//
// get the first item
//
hChild = TreeView_GetChild(
hWnd,
hRoot
);
//
// select it
//
TreeView_SelectItem(
hWnd,
hChild
);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// DeleteSelectedItem
//
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::DeleteSelectedItem(
HWND hWnd
)
{
HTREEITEM hItem;
//
// get current selections
//
hItem = TreeView_GetSelection( hWnd );
//
// delete it
//
TreeView_DeleteItem(
hWnd,
hItem
);
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// InitializeAddressTree
// initialize the address tree control with
// the address objects
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::InitializeAddressTree()
{
IEnumAddress * pEnumAddress;
ITAddress * pAddress;
HTREEITEM hChild;
HRESULT hr;
long l;
DWORD dwCount = 0;
//
// get the address enumerator
//
hr = gpTapi->EnumerateAddresses( &pEnumAddress );
if (S_OK != hr)
{
gpTapi->Release();
gpTapi = NULL;
return;
}
//
// go through all the address objects
// and add them to the address treecontrol
//
while (TRUE)
{
AADATA * pData;
hr = pEnumAddress->Next( 1, &pAddress, NULL );
if (S_OK != hr)
{
break;
}
AddAddressToTree( pAddress );
pAddress->Release();
pData = (AADATA *)CoTaskMemAlloc( sizeof ( AADATA ) );
pData->pAddress = pAddress;
pData->pTerminalPtrList = new TerminalPtrList;
gDataPtrList.push_back( pData );
dwCount++;
}
//
// release the enumerator
//
pEnumAddress->Release();
//
// select the first item
//
if (dwCount > 0)
{
SelectFirstItem(
ghAddressesWnd,
ghAddressesRoot
);
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// RegisterEventInterface
//
// registers the ITTAPIEventNotification interface
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void CT3testDlg::RegisterEventInterface()
{
CTAPIEventNotification * pTAPIEventNotification;
IConnectionPointContainer * pCPC;
IConnectionPoint * pCP;
IUnknown * pUnk;
//
// create the object
//
pTAPIEventNotification = new CTAPIEventNotification;
//
// get the connectionpointcontainer interface
// from the tapi object
//
gpTapi->QueryInterface(
IID_IConnectionPointContainer,
(void **) &pCPC
);
//
// get the connectionpoint we are
// looking for
//
pCPC->FindConnectionPoint(
IID_ITTAPIEventNotification,
&gpCP
);
pCPC->Release();
pTAPIEventNotification->QueryInterface(
IID_IUnknown,
(void **)&pUnk
);
//
// call the advise method to tell tapi
// about the interface
//
gpCP->Advise(
pUnk,
(ULONG *)&gulAdvise
);
//
// release our reference to
// it
//
pUnk->Release();
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// RegisterForCallNotifications
//
// registers for call state notifications for all
// addresses for outgoing calls
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::RegisterForCallNotifications()
{
VARIANT var;
var.vt = VT_ARRAY;
var.parray = NULL;
gpTapi->SetCallHubTracking(var, VARIANT_TRUE);
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// InitializeTrees
//
// Create and labels the tree controls
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::InitializeTrees()
{
TV_INSERTSTRUCT tvi;
tvi.hParent = TVI_ROOT;
tvi.hInsertAfter = TVI_FIRST;
tvi.item.mask = TVIF_TEXT;
//
// address tree
//
tvi.item.pszText = L"Addresses";
ghAddressesWnd = GetDlgItem( IDC_ADDRESSES )->m_hWnd;
ghAddressesRoot = TreeView_InsertItem(
ghAddressesWnd,
&tvi
);
//
// mediatypes tree
//
tvi.item.pszText = L"MediaTypes";
ghMediaTypesWnd = GetDlgItem( IDC_MEDIATYPES )->m_hWnd;
ghMediaTypesRoot = TreeView_InsertItem(
ghMediaTypesWnd,
&tvi
);
//
// terminals tree
//
tvi.item.pszText = L"Terminals";
ghTerminalsWnd = GetDlgItem( IDC_TERMINALS )->m_hWnd;
ghTerminalsRoot = TreeView_InsertItem(
ghTerminalsWnd,
&tvi
);
//
// calls tree
//
tvi.item.pszText = L"Calls";
ghCallsWnd = GetDlgItem( IDC_CALLS )->m_hWnd;
ghCallsRoot = TreeView_InsertItem(
ghCallsWnd,
&tvi
);
//
// selected media terminals tree
//
tvi.item.pszText = L"Selected Media Terminals";
ghSelectedWnd = GetDlgItem( IDC_SELECTEDTERMINALS )->m_hWnd;
ghSelectedRoot = TreeView_InsertItem(
ghSelectedWnd,
&tvi
);
//
// dynamic terminal classes tree
//
tvi.item.pszText = L"Dynamic Terminal Classes";
ghClassesWnd = GetDlgItem( IDC_DYNAMICCLASSES )->m_hWnd;
ghClassesRoot = TreeView_InsertItem(
ghClassesWnd,
&tvi
);
//
// created terminals tree
//
tvi.item.pszText = L"Created Terminals";
ghCreatedWnd = GetDlgItem( IDC_CREATEDTERMINALS )->m_hWnd;
ghCreatedRoot = TreeView_InsertItem(
ghCreatedWnd,
&tvi
);
//
// listen mediatypes tree
//
tvi.item.pszText = L"Listen MediaTypes";
ghListenWnd = GetDlgItem( IDC_LISTENMEDIAMODES )->m_hWnd;
ghListenRoot = TreeView_InsertItem(
ghListenWnd,
&tvi
);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnDestroy
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnDestroy()
{
CDialog::OnDestroy();
gfShuttingDown = TRUE;
//
// Release everything
//
ReleaseMediaTypes();
ReleaseTerminals();
ReleaseCalls();
ReleaseSelectedTerminals();
ReleaseCreatedTerminals();
ReleaseTerminalClasses();
ReleaseListen();
ReleaseAddresses();
DataPtrList::iterator iter, end;
iter = gDataPtrList.begin();
end = gDataPtrList.end();
for( ; iter != end; iter++ )
{
FreeData( *iter );
delete (*iter)->pTerminalPtrList;
CoTaskMemFree( *iter );
}
gDataPtrList.clear();
if (NULL != gpCP)
{
gpCP->Unadvise(gulAdvise);
gpCP->Release();
}
//
// shutdown TAPI
//
if (NULL != gpTapi)
{
gpTapi->Shutdown();
gpTapi->Release();
}
}
void
DoAddressCapStuff(ITTAPI * pTapi);
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnSelChangedAddresses
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnSelchangedAddresses(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
ITAddress * pAddress;
*pResult = 0;
//
// free all the stuff related to
// the address selected. this stuff
// will all be refilled in
//
ReleaseMediaTypes();
ReleaseListen();
ReleaseCalls();
ReleaseSelectedTerminals();
ReleaseCreatedTerminals();
//
// get the currently selected address
//
if (!GetAddress( &pAddress ))
{
return;
}
//
// update these trees
//
if ( !gfShuttingDown )
{
UpdateMediaTypes( pAddress );
UpdateCalls( pAddress );
}
}
/////////////////////////////////////////////////////////////////
// IsVideoCaptureStream
//
// Returns true if the stream is for video capture
/////////////////////////////////////////////////////////////////
BOOL
CT3testDlg::IsVideoCaptureStream(
ITStream * pStream
)
{
TERMINAL_DIRECTION tdStreamDirection;
long lStreamMediaType;
if ( FAILED( pStream ->get_Direction(&tdStreamDirection) ) ) { return FALSE; }
if ( FAILED( pStream ->get_MediaType(&lStreamMediaType) ) ) { return FALSE; }
return (tdStreamDirection == TD_CAPTURE) &&
(lStreamMediaType == TAPIMEDIATYPE_VIDEO);
}
/////////////////////////////////////////////////////////////////
// EnablePreview
//
// Selects a video render terminal on a video capture stream,
// thereby enabling video preview.
/////////////////////////////////////////////////////////////////
HRESULT
CT3testDlg::EnablePreview(
ITStream * pStream
)
{
ITTerminal * pTerminal;
HRESULT hr = GetVideoRenderTerminal(&pTerminal);
if ( SUCCEEDED(hr) )
{
hr = pStream->SelectTerminal(pTerminal);
pTerminal->Release();
}
return hr;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// SelectTerminalOnCall
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
HRESULT
CT3testDlg::SelectTerminalOnCall(
ITTerminal * pTerminal,
ITCallInfo * pCall
)
{
ITStreamControl * pStreamControl;
TERMINAL_DIRECTION termtd;
long lTermMediaType;
HRESULT hr;
pTerminal->get_Direction( &termtd );
pTerminal->get_MediaType( &lTermMediaType );
hr = pCall->QueryInterface(
IID_ITStreamControl,
(void**) &pStreamControl
);
if ( SUCCEEDED(hr) )
{
IEnumStream * pEnumStreams;
hr = pStreamControl->EnumerateStreams( &pEnumStreams );
if ( SUCCEEDED(hr) )
{
while (TRUE)
{
ITStream * pStream;
long lMediaType;
TERMINAL_DIRECTION td;
hr = pEnumStreams->Next( 1, &pStream, NULL );
if ( S_OK != hr )
{
hr = E_FAIL; // didn't select it anywhere
break;
}
pStream->get_MediaType( &lMediaType );
pStream->get_Direction( &td );
if ( ( lMediaType == lTermMediaType ) &&
( td == termtd) )
{
hr = pStream->SelectTerminal( pTerminal );
if ( FAILED(hr) )
{
::MessageBox(NULL, L"SelectTerminals failed", NULL, MB_OK);
}
else
{
//
// Also enable preview on the video capture stream.
//
if ( IsVideoCaptureStream( pStream ) )
{
EnablePreview( pStream );
}
pStream->Release();
break;
}
}
pStream->Release();
}
pEnumStreams->Release();
}
pStreamControl->Release();
}
return hr;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnAddTerminal
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnAddterminal()
{
ITCallInfo * pCall;
ITTerminal * pTerminal;
HRESULT hr = S_OK;
//
// get the selected call
//
if (!(GetCall( &pCall )))
{
return;
}
//
// get the selected terminal
//
if (!(GetTerminal( &pTerminal )))
{
return;
}
if (S_OK != hr)
{
::MessageBox(NULL, L"SelectTerminals failed", NULL, MB_OK);
return;
}
hr = SelectTerminalOnCall(pTerminal, pCall);
if ( FAILED(hr) )
{
return;
}
//
// put the terminal in the
// tree
//
AddSelectedTerminal(
pTerminal
);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// RemovePreview
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::RemovePreview( ITStream * pStream )
{
//
// This is a video capture stream and we've unselected the
// video capture terminal. If there is a video render
// terminal on the stream, then unselect it now.
//
IEnumTerminal * pEnum;
if ( FAILED( pStream->EnumerateTerminals( &pEnum ) ) )
{
return;
}
ITTerminal * pTerminal;
if ( S_OK == pEnum->Next(1, &pTerminal, NULL) )
{
pStream->UnselectTerminal( pTerminal );
pTerminal->Release();
}
pEnum->Release();
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnRemoveTerminal
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnRemoveterminal()
{
ITTerminal * pTerminal;
ITCallInfo * pCall;
HTREEITEM hItem;
HRESULT hr;
ITBasicCallControl * pBCC;
//
// get current call
//
if (!GetCall( &pCall ))
{
return;
}
//
// get current terminal
//
if (!GetSelectedTerminal(&pTerminal))
{
return;
}
TERMINAL_DIRECTION termtd;
long lTermMediaType;
pTerminal->get_Direction( &termtd );
pTerminal->get_MediaType( &lTermMediaType );
ITStreamControl * pStreamControl;
hr = pCall->QueryInterface(
IID_ITStreamControl,
(void**) &pStreamControl
);
BOOL bFound = FALSE;
if ( SUCCEEDED(hr) )
{
IEnumStream * pEnumStreams;
hr = pStreamControl->EnumerateStreams( &pEnumStreams );
if ( SUCCEEDED(hr) )
{
while ( ! bFound )
{
ITStream * pStream;
long lMediaType;
TERMINAL_DIRECTION td;
hr = pEnumStreams->Next( 1, &pStream, NULL );
if ( S_OK != hr )
{
break;
}
pStream->get_MediaType( &lMediaType );
pStream->get_Direction( &td );
if ( ( lMediaType == lTermMediaType ) &&
( td == termtd) )
{
hr = pStream->UnselectTerminal( pTerminal );
if ( !SUCCEEDED(hr) )
{
::MessageBox(NULL, L"UnselectTerminals failed", NULL, MB_OK);
}
else
{
if ( IsVideoCaptureStream( pStream ) )
{
RemovePreview( pStream );
}
bFound = TRUE;
}
}
pStream->Release();
}
pEnumStreams->Release();
}
pStreamControl->Release();
}
if ( !bFound )
{
return;
}
//
// remove it from tree
//
hItem = TreeView_GetSelection( ghSelectedWnd );
TreeView_DeleteItem(
ghSelectedWnd,
hItem
);
//
// release tree's reference to
// the terminal
//
pTerminal->Release();
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnCreateCall
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnCreatecall()
{
ITAddress * pAddress;
HRESULT hr;
ITBasicCallControl * pCall;
ITCallInfo * pCallInfo;
BOOL bConference = FALSE;
BOOL lAddressType = LINEADDRESSTYPE_PHONENUMBER;
BSTR bstrDestAddress;
ITAddressCapabilities * pAddressCaps;
long lType = 0;
ITMediaSupport * pMediaSupport;
long lSupportedMediaTypes, lMediaTypes = 0;
//
// get the current address
//
if (!GetAddress( &pAddress ))
{
return;
}
hr = pAddress->QueryInterface(IID_ITAddressCapabilities, (void**)&pAddressCaps);
hr = pAddressCaps->get_AddressCapability( AC_ADDRESSTYPES, &lType );
if ( SUCCEEDED(hr) && (LINEADDRESSTYPE_SDP & lType) )
{
bConference = TRUE;
lAddressType = LINEADDRESSTYPE_SDP;
}
if ( SUCCEEDED(hr) && (LINEADDRESSTYPE_DOMAINNAME & lType) )
{
lAddressType = LINEADDRESSTYPE_DOMAINNAME;
}
pAddressCaps->Release();
if ( !bConference )
{
//
// create the dialog to get the
// dial string
//
CCreateCallDlg Dlg( this );
if (IDOK == Dlg.DoModal())
{
//
// create a call with the
// string input in the dialog
//
bstrDestAddress = SysAllocString( Dlg.m_pszDestAddress );
}
else
{
return;
}
}
else
{
CConfDlg Dlg;
if ( IDOK == Dlg.DoModal() )
{
bstrDestAddress = Dlg.m_bstrDestAddress;
}
else
{
return;
}
}
//
// Find out if the address supports audio, video, or both.
//
pAddress->QueryInterface(
IID_ITMediaSupport,
(void**)&pMediaSupport
);
pMediaSupport->get_MediaTypes( &lSupportedMediaTypes );
pMediaSupport->Release();
if ( lSupportedMediaTypes & TAPIMEDIATYPE_AUDIO )
{
lMediaTypes |= TAPIMEDIATYPE_AUDIO;
}
if ( lSupportedMediaTypes & TAPIMEDIATYPE_VIDEO )
{
lMediaTypes |= TAPIMEDIATYPE_VIDEO;
}
if ( lMediaTypes == 0 )
{
if ( lSupportedMediaTypes & TAPIMEDIATYPE_DATAMODEM )
{
lMediaTypes |= TAPIMEDIATYPE_DATAMODEM;
}
}
//
// Create the call.
//
hr = pAddress->CreateCall(
bstrDestAddress,
lAddressType,
lMediaTypes,
&pCall
);
SysFreeString( bstrDestAddress );
if (S_OK != hr)
{
::MessageBox(NULL, L"CreateCall failed", NULL, MB_OK);
return;
}
//
// get the callinfo interface
//
pCall->QueryInterface( IID_ITCallInfo, (void **)&pCallInfo );
//
// add the call to the tree
//
AddCall(pCallInfo);
//
// update the callinfo
//
UpdateCall( pCallInfo );
//
// release this inteface
//
pCallInfo->Release();
//
// note that we keep a global reference to the call
// (CreateCall returns with a reference count of 1)
// so the call does not get destroyed. When we want
// the call to actually be destroyed, then we
// release twice.
//
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnConnect
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnConnect()
{
ITBasicCallControl * pCall;
ITCallInfo * pCallInfo;
HRESULT hr = S_OK;
//
// get the current call
//
if (!GetCall( &pCallInfo))
{
return;
}
//
// get the call control interface
//
hr = pCallInfo->QueryInterface(IID_ITBasicCallControl, (void **)&pCall);
if (S_OK != hr)
{
::MessageBox(NULL, L"Connect failed", NULL, MB_OK);
return;
}
//
// call connect
//
hr = pCall->Connect( FALSE );
//
// release this interface
//
pCall->Release();
if (S_OK != hr)
{
::MessageBox(NULL, L"Connect failed", NULL, MB_OK);
return;
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnDrop
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnDrop()
{
ITBasicCallControl * pCall;
ITCallInfo * pCallInfo;
HRESULT hr = S_OK;
//
// get the current call
//
if (!GetCall( &pCallInfo ))
{
return;
}
//
// get the bcc interface
//
hr = pCallInfo->QueryInterface(
IID_ITBasicCallControl,
(void **)&pCall
);
if (S_OK != hr)
{
::MessageBox(NULL, L"Disconnect failed", NULL, MB_OK);
return;
}
//
// call disconnect
//
hr = pCall->Disconnect( DC_NORMAL );
//
// release this reference
//
pCall->Release();
if (S_OK != hr)
{
::MessageBox(NULL, L"Disconnect failed", NULL, MB_OK);
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnDrop
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnAnswer()
{
ITCallInfo * pCallInfo;
ITBasicCallControl * pCall;
HRESULT hr = S_OK;
//
// get the current call
//
if (!GetCall( &pCallInfo))
{
return;
}
//
// get the bcc interface
//
hr = pCallInfo->QueryInterface(IID_ITBasicCallControl, (void **)&pCall);
if (S_OK != hr)
{
::MessageBox(NULL, L"Answer failed", NULL, MB_OK);
return;
}
//
// answer it
//
hr = pCall->Answer( );
//
// release this interface
//
pCall->Release();
if (S_OK != hr)
{
::MessageBox(NULL, L"Answer failed", NULL, MB_OK);
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnListen
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnListen()
{
ITAddress * pAddress;
HRESULT hr = S_OK;
DWORD dwCookie;
HTREEITEM hItem;
long ulRegister;
DWORD dwMediaMode = 0;
//
// get the current address
//
if (!GetAddress( &pAddress ))
{
return;
}
hItem = TreeView_GetChild(
ghListenWnd,
ghListenRoot
);
while (NULL != hItem)
{
TV_ITEM item;
item.mask = TVIF_HANDLE | TVIF_PARAM;
item.hItem = hItem;
//
// get it
//
TreeView_GetItem(
ghListenWnd,
&item
);
dwMediaMode |= (DWORD)(item.lParam);
hItem = TreeView_GetNextSibling(
ghAddressesWnd,
hItem
);
}
hr = gpTapi->RegisterCallNotifications(
pAddress,
VARIANT_TRUE,
VARIANT_TRUE,
(long)dwMediaMode,
gulAdvise,
&ulRegister
);
if (S_OK != hr)
{
::MessageBox(NULL, L"RegisterCallNotifications failed", NULL, MB_OK);
}
//
// release all the mediatypes
// in the listen tree
//
ReleaseListen();
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnSelChangedCalls
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnSelchangedCalls(NMHDR* pNMHDR, LRESULT* pResult)
{
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnRelease()
//
// this is called to release all references to a call
//
// if a call is selected it has two references - once for
// the tree control, and once for our global reference.
// release both here.
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnRelease()
{
ITCallInfo * pCallInfo;
//
// get the call
//
if (!GetCall( &pCallInfo ))
{
return;
}
//
// these depend on the call,
// so release them
//
ReleaseSelectedTerminals();
ReleaseCreatedTerminals();
//
// delete it from the tree
//
DeleteSelectedItem(
ghCallsWnd
);
//
// release once for the tree view
//
pCallInfo->Release();
//
// release a second time for our global reference
//
pCallInfo->Release();
}
void
CT3testDlg::HelpCreateTerminal(
ITTerminalSupport * pTerminalSupport,
BSTR bstrClass,
long lMediaType,
TERMINAL_DIRECTION dir
)
{
ITTerminal * pTerminal;
HRESULT hr;
//
// create it
//
hr = pTerminalSupport->CreateTerminal(
bstrClass,
lMediaType,
dir,
&pTerminal
);
if (S_OK != hr)
{
return;
}
//
// ZoltanS:
// We do nothing special with our video windows. Just make them visible
// all the time. If this isn't a video window we just skip this step.
//
IVideoWindow * pWindow;
if ( SUCCEEDED( pTerminal->QueryInterface(IID_IVideoWindow,
(void **) &pWindow) ) )
{
pWindow->put_AutoShow( VARIANT_TRUE );
pWindow->Release();
}
//
// add the terminal
//
AddCreatedTerminal(
pTerminal
);
//
// release our reference
//
pTerminal->Release();
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// GetVideoRenderTerminal
//
// this is used to create a video render terminal for preview
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
HRESULT CT3testDlg::GetVideoRenderTerminal(ITTerminal ** ppTerminal)
{
//
// Get the current address
//
ITAddress * pAddress;
if (!GetAddress( &pAddress ))
{
return E_FAIL;
}
//
// get the terminal support interface
//
ITTerminalSupport * pTerminalSupport;
HRESULT hr;
hr = pAddress->QueryInterface(
IID_ITTerminalSupport,
(void **) &pTerminalSupport
);
if ( FAILED(hr) )
{
return hr;
}
//
// Construct a BSTR for the correct IID.
//
LPOLESTR lpTerminalClass;
hr = StringFromIID(CLSID_VideoWindowTerm,
&lpTerminalClass);
BSTR bstrTerminalClass;
if ( FAILED(hr) )
{
pTerminalSupport->Release();
return hr;
}
bstrTerminalClass = SysAllocString ( lpTerminalClass );
CoTaskMemFree( lpTerminalClass );
if ( bstrTerminalClass == NULL )
{
pTerminalSupport->Release();
return E_OUTOFMEMORY;
}
//
// create it
//
hr = pTerminalSupport->CreateTerminal(
bstrTerminalClass,
TAPIMEDIATYPE_VIDEO,
TD_RENDER,
ppTerminal
);
pTerminalSupport->Release();
if ( FAILED(hr) )
{
*ppTerminal = NULL;
return hr;
}
//
// We do nothing special with our video windows. Just make them visible
// all the time.
//
IVideoWindow * pWindow;
if ( FAILED( (*ppTerminal)->QueryInterface(IID_IVideoWindow,
(void **) &pWindow) ) )
{
(*ppTerminal)->Release();
*ppTerminal = NULL;
return hr;
}
pWindow->put_AutoShow( VARIANT_TRUE );
pWindow->Release();
return S_OK;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnCreateTerminal
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnCreateTerminal()
{
//
// Get the selected media type.
//
long lMediaType;
if (!GetMediaType( &lMediaType ))
{
return;
}
//
// Get the current address
//
ITAddress * pAddress;
if (!GetAddress( &pAddress ))
{
return;
}
//
// Get the selected terminal class.
//
BSTR bstrClass;
if (!GetTerminalClass( &bstrClass ))
{
return;
}
//
// get the terminal support interface
//
ITTerminalSupport * pTerminalSupport;
HRESULT hr;
hr = pAddress->QueryInterface(
IID_ITTerminalSupport,
(void **) &pTerminalSupport
);
if ( FAILED(hr) )
{
SysFreeString( bstrClass );
return;
}
//
// Convert the terminal class from a BSTR to an IID.
//
IID iidTerminalClass;
IIDFromString(
bstrClass,
&iidTerminalClass
);
//
// Create and add the terminal.
//
if ( CLSID_VideoWindowTerm == iidTerminalClass )
{
HelpCreateTerminal(
pTerminalSupport,
bstrClass,
lMediaType,
TD_RENDER
);
}
//
// Release references.
//
pTerminalSupport->Release();
SysFreeString(bstrClass);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnReleaseTerminal
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnReleaseterminal()
{
ITTerminal * pTerminal;
//
// get the terminal
//
if (GetCreatedTerminal( &pTerminal ))
{
//
// and release it!
//
pTerminal->Release();
//
// delete it from the tree
//
DeleteSelectedItem(
ghCreatedWnd
);
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnAddCreated
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnAddcreated()
{
ITTerminal * pTerminal;
ITCallInfo * pCall;
HRESULT hr = S_OK;
ITBasicCallControl * pBCC;
//
// get the current call
//
if (!(GetCall( &pCall )))
{
return;
}
//
// GetCreatedTerminal
//
if (!GetCreatedTerminal( &pTerminal ))
{
return;
}
//
// Select the terminal on the call.
//
hr = SelectTerminalOnCall(pTerminal, pCall);
if ( FAILED(hr) )
{
::MessageBox(NULL, L"SelectTerminals failed", NULL, MB_OK);
return;
}
//
// add to the selected window
//
AddSelectedTerminal(
pTerminal
);
//
// delete from the created window
//
DeleteSelectedItem(
ghCreatedWnd
);
//
// release because there was a reference to
// this terminal in the created wnd
//
pTerminal->Release();
return;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnAddNull
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnAddnull()
{
return;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnAddToListen
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnAddtolisten()
{
long lMediaType;
//
// get the current mediatype
//
if (!GetMediaType( &lMediaType ))
{
return;
}
//
// add it
//
AddListen( lMediaType );
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnListenAll
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnListenall()
{
ITAddress * pAddress;
HRESULT hr = S_OK;
long ulRegister;
long lMediaType;
ITMediaSupport * pMediaSupport;
//
// get the currently selected address
//
if (!GetAddress( &pAddress ))
{
return;
}
pAddress->QueryInterface(
IID_ITMediaSupport,
(void **)&pMediaSupport
);
pMediaSupport->get_MediaTypes( &lMediaType );
//
// register
//
gpTapi->RegisterCallNotifications(
pAddress,
TRUE,
TRUE,
lMediaType,
gulAdvise,
&ulRegister
);
if (S_OK != hr)
{
::MessageBox(NULL, L"RegisterCallTypes failed", NULL, MB_OK);
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
//
// OnSelChangedMedia
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
void CT3testDlg::OnSelchangedMediatypes(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
long lMediaType;
ITAddress * pAddress;
HRESULT hr;
*pResult = 0;
if (gbUpdatingStuff)
return;
//
// get the current mediatype
//
if (!GetMediaType( &lMediaType ))
{
return;
}
//
// get the current address
//
if (!GetAddress( &pAddress ))
{
return;
}
//
// we only show terminals that relate
// to the selected mediatype
// so get rid of the old ones
//
ReleaseTerminals();
ReleaseTerminalClasses();
UpdateTerminals( pAddress, lMediaType );
UpdateTerminalClasses( pAddress, lMediaType );
}
void CT3testDlg::OnRclickSelectedterminals(NMHDR* pNMHDR, LRESULT* pResult)
{
POINT pt;
HTREEITEM hItem;
TV_HITTESTINFO hittestinfo;
RECT rc;
*pResult = 0;
//
// get the location of the cursor
//
GetCursorPos( &pt );
//
// get the control's window
//
::GetWindowRect(
ghSelectedWnd,
&rc
);
//
// adjust the point to
// the child's coords
//
hittestinfo.pt.x = pt.x - rc.left;
hittestinfo.pt.y = pt.y - rc.top;
//
// hittest to get the tree view item
//
hItem = TreeView_HitTest(
ghSelectedWnd,
&hittestinfo
);
//
// only display a menu if the mouse is actually
// over the item (TVHT_ONITEM)
//
if (hItem == NULL || (!(hittestinfo.flags & TVHT_ONITEM)) )
{
return;
}
//
// select that item (right clicking will not select
// by default
//
TreeView_Select(
ghSelectedWnd,
hItem,
TVGN_CARET
);
CreateSelectedTerminalMenu(
pt,
m_hWnd
);
}
#ifdef ENABLE_DIGIT_DETECTION_STUFF
void CT3testDlg::OnModesSupported()
{
ITTerminal * pTerminal;
ITDigitGenerationTerminal * pDigitGeneration;
HRESULT hr = S_OK;
LONG lDigits;
if (!GetSelectedTerminal(&pTerminal))
{
return;
}
hr = pTerminal->QueryInterface(
IID_ITDigitGenerationTerminal,
(void **) &pDigitGeneration
);
if (!SUCCEEDED(hr))
{
return;
}
pDigitGeneration->get_ModesSupported( &lDigits );
pDigitGeneration->Release();
}
void CT3testDlg::OnGenerate()
{
ITTerminal * pTerminal;
ITDigitGenerationTerminal * pDigitGeneration;
HRESULT hr = S_OK;
if (!GetSelectedTerminal(&pTerminal))
{
return;
}
hr = pTerminal->QueryInterface(
IID_ITDigitGenerationTerminal,
(void **) &pDigitGeneration
);
if (!SUCCEEDED(hr))
{
return;
}
hr = pDigitGeneration->Generate(
L"12345",
LINEDIGITMODE_DTMF
);
pDigitGeneration->Release();
}
void CT3testDlg::OnModesSupported2()
{
ITTerminal * pTerminal;
ITDigitDetectionTerminal * pDigitDetection;
HRESULT hr = S_OK;
LONG lDigits;
if (!GetSelectedTerminal(&pTerminal))
{
return;
}
hr = pTerminal->QueryInterface(
IID_ITDigitDetectionTerminal,
(void **) &pDigitDetection
);
if (!SUCCEEDED(hr))
{
return;
}
pDigitDetection->get_ModesSupported( &lDigits );
pDigitDetection->Release();
}
void CT3testDlg::OnStartDetect()
{
ITTerminal * pTerminal;
ITDigitDetectionTerminal * pDigitDetection;
HRESULT hr = S_OK;
LONG lDigits;
ULONG ulAdvise;
IConnectionPointContainer * pCPC;
IConnectionPoint * pCP;
if (!GetSelectedTerminal(&pTerminal))
{
return;
}
hr = pTerminal->QueryInterface(
IID_ITDigitDetectionTerminal,
(void **) &pDigitDetection
);
if (!SUCCEEDED(hr))
{
return;
}
hr = pTerminal->QueryInterface(
IID_IConnectionPointContainer,
(void **)&pCPC
);
if (!SUCCEEDED(hr))
{
pDigitDetection->Release();
return;
}
gpDigitNotification = new CDigitDetectionNotification;
hr = pCPC->FindConnectionPoint(
IID_ITDigitDetectionNotification,
&pCP
);
pCPC->Release();
IUnknown * pUnk;
gpDigitNotification->QueryInterface(
IID_IUnknown,
(void**)&pUnk
);
hr = pCP->Advise(
pUnk,
&ulAdvise
);
pUnk->Release();
pCP->Release();
pDigitDetection->StartDetect(LINEDIGITMODE_DTMF);
pDigitDetection->Release();
}
void CT3testDlg::OnStopDetect()
{
ITTerminal * pTerminal;
ITDigitDetectionTerminal * pDigitDetection;
HRESULT hr = S_OK;
LONG lDigits;
if (!GetSelectedTerminal(&pTerminal))
{
return;
}
hr = pTerminal->QueryInterface(
IID_ITDigitDetectionTerminal,
(void **) &pDigitDetection
);
if (!SUCCEEDED(hr))
{
return;
}
pDigitDetection->StopDetect();
pDigitDetection->Release();
}
#endif // ENABLE_DIGIT_DETECTION_STUFF
void CT3testDlg::OnRclickCalls(NMHDR* pNMHDR, LRESULT* pResult)
{
POINT pt;
HTREEITEM hItem;
TV_HITTESTINFO hittestinfo;
RECT rc;
*pResult = 0;
//
// get the location of the cursor
//
GetCursorPos( &pt );
//
// get the control's window
//
::GetWindowRect(
ghCallsWnd,
&rc
);
//
// adjust the point to
// the child's coords
//
hittestinfo.pt.x = pt.x - rc.left;
hittestinfo.pt.y = pt.y - rc.top;
//
// hittest to get the tree view item
//
hItem = TreeView_HitTest(
ghCallsWnd,
&hittestinfo
);
//
// only display a menu if the mouse is actually
// over the item (TVHT_ONITEM)
//
if (hItem == NULL || (!(hittestinfo.flags & TVHT_ONITEM)) )
{
return;
}
//
// select that item (right clicking will not select
// by default
//
TreeView_Select(
ghCallsWnd,
hItem,
TVGN_CARET
);
}
void CT3testDlg::OnConfigAutoAnswer()
{
ITAddress * pAddress;
autoans dlg;
DataPtrList::iterator dataiter, dataend;
if (!GetAddress( &pAddress ) )
{
return;
}
dataiter = gDataPtrList.begin();
dataend = gDataPtrList.end();
for ( ; dataiter != dataend; dataiter++ )
{
if ( pAddress == (*dataiter)->pAddress )
{
break;
}
}
if ( dataiter == dataend )
{
return;
}
FreeData( (*dataiter) );
if (IDOK == dlg.DoModal())
{
TerminalPtrList::iterator iter, end;
DWORD dwCount;
long lRegister;
HRESULT hr;
long lMediaType = 0;
dwCount = dlg.m_TerminalPtrList.size();
if ( 0 == dwCount )
{
return;
}
iter = dlg.m_TerminalPtrList.begin();
end = dlg.m_TerminalPtrList.end();
for ( ; iter != end ; iter++ )
{
long l;
(*dataiter)->pTerminalPtrList->push_back( *iter );
if ( NULL != (*iter) )
{
(*iter)->get_MediaType( &l );
lMediaType |= l;
}
else
{
lMediaType |= (long)LINEMEDIAMODE_VIDEO;
}
}
//
// call register call types
//
hr = gpTapi->RegisterCallNotifications(
pAddress,
VARIANT_FALSE,
VARIANT_TRUE,
lMediaType,
0,
&lRegister
);
}
}
void CT3testDlg::FreeData( AADATA * pData )
{
TerminalPtrList::iterator iter, end;
iter = pData->pTerminalPtrList->begin();
end = pData->pTerminalPtrList->end();
for ( ; iter != end; iter++ )
{
if ( NULL != (*iter) )
{
(*iter)->Release();
}
}
pData->pTerminalPtrList->clear();
}
void CT3testDlg::OnClose()
{
CDialog::OnClose();
}
void CT3testDlg::OnILS()
{
CILSDlg dlg;
if (IDOK == dlg.DoModal())
{
}
}
void CT3testDlg::OnRate()
{
CRateDlg dlg;
ITCallInfo * pCallInfo;
if ( !GetCall( &pCallInfo ) )
{
return;
}
if (IDOK == dlg.DoModal() )
{
pCallInfo->put_CallInfoLong(CIL_MINRATE, dlg.m_dwMinRate );
pCallInfo->put_CallInfoLong(CIL_MAXRATE, dlg.m_dwMaxRate );
}
}
void CT3testDlg::OnPark1()
{
ITCallInfo * pCall;
ITBasicCallControl * pBCC;
HRESULT hr;
//
// get the call in question
//
if (!GetCall( &pCall ))
{
return;
}
pCall->QueryInterface(
IID_ITBasicCallControl,
(void**)&pBCC
);
hr = pBCC->ParkDirect( L"101");
pBCC->Release();
}
void CT3testDlg::OnPark2()
{
ITCallInfo * pCall;
ITBasicCallControl * pBCC;
HRESULT hr;
BSTR pAddress;
//
// get the call in question
//
if (!GetCall( &pCall ))
{
return;
}
pCall->QueryInterface(
IID_ITBasicCallControl,
(void **)&pBCC
);
hr = pBCC->ParkIndirect( &pAddress );
SysFreeString( pAddress );
pBCC->Release();
}
void CT3testDlg::OnHandoff1()
{
ITCallInfo * pCall;
ITBasicCallControl * pBCC;
HRESULT hr;
//
// get the call in question
//
if (!GetCall( &pCall ))
{
return;
}
pCall->QueryInterface(
IID_ITBasicCallControl,
(void **)&pBCC
);
pBCC->HandoffDirect( L"tb20.exe" );
pBCC->Release();
}
void CT3testDlg::OnHandoff2()
{
ITCallInfo * pCall;
ITBasicCallControl * pBCC;
HRESULT hr;
//
// get the call in question
//
if (!GetCall( &pCall ))
{
return;
}
pCall->QueryInterface(
IID_ITBasicCallControl,
(void **)&pBCC
);
pBCC->HandoffIndirect( TAPIMEDIATYPE_AUDIO );
pBCC->Release();
}
void CT3testDlg::OnUnpark()
{
ITCallInfo * pCall;
ITBasicCallControl * pBCC;
HRESULT hr;
//
// get the call in question
//
if (!GetCall( &pCall ))
{
return;
}
pCall->QueryInterface(
IID_ITBasicCallControl,
(void **)&pBCC
);
pBCC->Unpark();
pBCC->Release();
}
void CT3testDlg::OnPickup1()
{
ITCallInfo * pCall;
ITBasicCallControl * pBCC;
HRESULT hr;
//
// get the call in question
//
if (!GetCall( &pCall ))
{
return;
}
pCall->QueryInterface(
IID_ITBasicCallControl,
(void **)&pBCC
);
pBCC->Pickup( NULL );
pBCC->Release();
}
void CT3testDlg::OnPickup2()
{
ITCallInfo * pCall;
ITBasicCallControl * pBCC;
HRESULT hr;
//
// get the call in question
//
if (!GetCall( &pCall ))
{
return;
}
pCall->QueryInterface(
IID_ITBasicCallControl,
(void **)&pBCC
);
}
Reference in a new issue Copy permalink