//--------------------------------------------------------------------------// // Header Files. // //--------------------------------------------------------------------------// #include "precomp.h" #include "resource.h" #include "help_ids.h" #include "dlgcall2.h" #include "mrulist2.h" #include "dlgacd.h" #include "dlgCall2.h" #include "calv.h" #include "dirutil.h" #include "callto.h" #include "conf.h" #include "confroom.h" #include "confpolicies.h" extern void UpdateSecurityCheck(CConfRoom *pConfRoom, HWND hDlg, UINT idCheck); //--------------------------------------------------------------------------// // CDlgAcd::CDlgAcd. // //--------------------------------------------------------------------------// CDlgAcd::CDlgAcd(CConfRoom *pConfRoom): m_hwnd( NULL ), m_nameCombo( NULL ), m_addressTypeCombo( NULL ), m_pRai( NULL ), m_mruRai( NULL ), m_pConfRoom( pConfRoom ), m_secure( false ) { // Ensure the common controls are loaded... INITCOMMONCONTROLSEX icc; icc.dwSize = sizeof(icc); icc.dwICC = ICC_WIN95_CLASSES | ICC_COOL_CLASSES | ICC_USEREX_CLASSES; InitCommonControlsEx( &icc ); } // End of CDlgAcd::CDlgAcd. //--------------------------------------------------------------------------// // CDlgAcd::~CDlgAcd. // //--------------------------------------------------------------------------// CDlgAcd::~CDlgAcd() { ClearRai( &m_mruRai ); } // End of CDlgAcd::~CDlgAcd. //--------------------------------------------------------------------------// // CDlgAcd::doModal. // //--------------------------------------------------------------------------// INT_PTR CDlgAcd::doModal ( HWND parent, RichAddressInfo * rai, bool & secure ){ INT_PTR result; m_pRai = rai; m_secure = secure; result = DialogBoxParam( ::GetInstanceHandle(), MAKEINTRESOURCE( IDD_ACD ), parent, DlgProcAcd, (LPARAM) this ); secure = m_secure; return( result ); } // End of CDlgAcd::doModal. //--------------------------------------------------------------------------// // CDlgAcd::DlgProcAcd. // //--------------------------------------------------------------------------// INT_PTR CALLBACK CDlgAcd::DlgProcAcd ( HWND dialog, UINT message, WPARAM wParam, LPARAM lParam ){ static const DWORD helpIDMap[] = { IDC_STATIC_ADDRESS, IDH_GENERAL_GENERAL, IDB_ACD_ADDRESS, IDH_PLACECALL_TO_TEXT, IDL_ACD_ADDRESS, IDH_PLACECALL_TO_TEXT, IDC_ACD_USING_STATIC, IDH_PLACECALL_USING, IDL_ACD_ADDR_TYPE, IDH_PLACECALL_USING, IDC_SECURE_CALL, IDH_PLACECALL_SECURITY_CHKBX, IDC_ACD_DIRECTORY, IDH_PLACECALL_TO, IDOK, IDH_PLACECALL_CALL, 0, 0 }; bool result = false; switch( message ) { case WM_INITDIALOG: { ASSERT(NULL != lParam); ::SetWindowLongPtr( dialog, DWLP_USER, lParam ); result = ((CDlgAcd *) lParam)->onInitDialog( dialog ); } break; case WM_COMMAND: { CDlgAcd * acd = (CDlgAcd *) ::GetWindowLongPtr( dialog, DWLP_USER ); if( acd != NULL ) { result = acd->onCommand( LOWORD( wParam ), HIWORD( wParam ) ); } } break; case WM_CONTEXTMENU: { DoHelpWhatsThis( wParam, helpIDMap ); } break; case WM_HELP: { DoHelp( lParam, helpIDMap ); } break; } return( (BOOL) result ); } // End of CDlgAcd::DlgProcAcd. //--------------------------------------------------------------------------// // CDlgAcd::onInitDialog. // //--------------------------------------------------------------------------// bool CDlgAcd::onInitDialog ( HWND dialog ){ m_hwnd = dialog; UpdateSecurityCheck(m_pConfRoom, m_hwnd, IDC_SECURE_CALL); HICON directoryIcon = LoadIcon( ::GetInstanceHandle(), MAKEINTRESOURCE( IDI_DIRECTORY ) ); if( directoryIcon != NULL ) { ::SendDlgItemMessage( dialog, IDC_ACD_DIRECTORY, BM_SETIMAGE, IMAGE_ICON, (LPARAM) directoryIcon ); } m_nameCombo = GetDlgItem( m_hwnd, IDL_ACD_ADDRESS ); m_addressTypeCombo = GetDlgItem( m_hwnd, IDL_ACD_ADDR_TYPE ); ComboBox_LimitText( m_nameCombo, CCHMAXSZ_ADDRESS - 1 ); fillCallMruList(); fillAddressTypesList(); ::SendMessage( m_nameCombo, EM_LIMITTEXT, CCallto::s_iMaxAddressLength, 0 ); if( hasValidUserInfo( m_pRai ) ) { ::SetWindowText( m_nameCombo, m_pRai->szName ); ::SendMessage( m_addressTypeCombo, CB_SETCURSEL, m_pRai->rgDwStr[ 0 ].dw, 0 ); } else { ::SendMessage( m_addressTypeCombo, CB_SETCURSEL, 0, 0 ); } CenterWindow( m_hwnd, ::GetParent( m_hwnd ) ); if (m_pConfRoom->FIsConferenceActive()) { // Simulate a call started to get all the states right OnCallStarted(); } return( true ); // Default focus... } // End of CDlgAcd::onInitDialog. //--------------------------------------------------------------------------// // CDlgAcd::fillCallMruList. // //--------------------------------------------------------------------------// void CDlgAcd::fillCallMruList(void) { ASSERT(NULL != m_nameCombo); COMBOBOXEXITEM cbi; ClearStruct( &cbi ); cbi.mask = CBEIF_TEXT; cbi.iItem = -1; // Always insert at the end... HRESULT result = S_OK; for( int nn = 0; result == S_OK; nn++ ) { RichAddressInfo * rai; if( (result = m_callMruList.GetAddress( nn, &rai )) == S_OK ) { cbi.pszText = rai->szName; cbi.cchTextMax = lstrlen( cbi.pszText ); int index = (int)::SendMessage( m_nameCombo, CBEM_INSERTITEM, 0, (LPARAM) &cbi ); if( index != CB_ERR ) { ::SendMessage( m_nameCombo, CB_SETITEMDATA, index, nn ); } else { result = S_FALSE; } ClearRai( &rai ); } } } // End of CDlgAcd::fillCallMruList. //--------------------------------------------------------------------------// // CDlgAcd::fillAddressTypesList. // //--------------------------------------------------------------------------// void CDlgAcd::fillAddressTypesList(void) { using namespace ConfPolicies; enum CallMode { CM_GK = 0x0001, // GateKeeper CM_GW = 0x0002, // Gateway CM_NoGate = 0x0004, // Neither } ; static const struct { LPARAM dwCallType; UINT idTitle; UINT uCallMode; } s_mpCtIds[] = { { NM_ADDR_UNKNOWN, IDS_ACD_CT_AUTOMATIC, CM_GK|CM_GW|CM_NoGate }, { NM_ADDR_MACHINENAME, IDS_ACD_CT_IP, CM_GW|CM_NoGate }, { NM_ADDR_ULS, IDS_ACD_CT_ILS, CM_GW|CM_NoGate }, { NM_ADDR_ALIAS_E164, IDS_ACD_CT_PHONE, CM_GK|CM_GW }, { NM_ADDR_ALIAS_ID, IDS_ACD_CT_ALIAS, CM_GK }, } ; HWND combo = GetDlgItem( m_hwnd, IDL_ACD_ADDR_TYPE ); if( combo != NULL ) { UINT uCallType = CM_NoGate; if (CallingMode_GateKeeper == GetCallingMode()) { uCallType = CM_GK; } else { RegEntry reConf(CONFERENCING_KEY, HKEY_CURRENT_USER); if (reConf.GetNumber( REGVAL_USE_H323_GATEWAY ) != 0) { uCallType = CM_GW; } } for( int nn = 0; nn < ARRAY_ELEMENTS(s_mpCtIds); nn++ ) { if (0 == (uCallType & s_mpCtIds[nn].uCallMode)) { continue; } TCHAR sz[ CCHMAXSZ_NAME ]; if( FLoadString( s_mpCtIds[ nn ].idTitle, sz, CCHMAX( sz ) ) ) { int index = (int)::SendMessage( combo, CB_INSERTSTRING, -1, (LPARAM) sz ); if( index != CB_ERR ) { ::SendMessage( combo, CB_SETITEMDATA, index, s_mpCtIds[ nn ].dwCallType ); } } } } } // End of CDlgAcd::fillAddressTypesList. //--------------------------------------------------------------------------// // CDlgAcd::onCommand. // //--------------------------------------------------------------------------// bool CDlgAcd::onCommand ( int command, int notification ){ ASSERT(NULL != m_hwnd); bool result = false; switch( command ) { case IDC_SECURE_CALL: { m_secure = (IsDlgButtonChecked( m_hwnd, IDC_SECURE_CALL ) == BST_CHECKED); } break; case IDL_ACD_ADDRESS: { if( notification == CBN_EDITCHANGE ) { onEditChange(); } else if( notification == CBN_SELCHANGE ) { int iSel = (int)::SendMessage( m_nameCombo, CB_GETCURSEL, 0, 0 ); if (iSel >= 0) { onMruSelect( iSel ); } } } break; case IDL_ACD_ADDR_TYPE: if (CBN_SELCHANGE == notification) { // Pretend like the user just typed in the edit control onEditChange(); } break; case IDC_ACD_DIRECTORY: { CFindSomeone::findSomeone(m_pConfRoom); ::EndDialog( m_hwnd, IDCANCEL ); } break; case IDOK: { if( m_mruRai != NULL ) { lstrcpy( m_pRai->szName, m_mruRai->szName ); m_pRai->cItems = m_mruRai->cItems; for( int nn = 0; nn < m_mruRai->cItems; nn++ ) { m_pRai->rgDwStr[ nn ].dw = m_mruRai->rgDwStr[ nn ].dw; m_pRai->rgDwStr[ nn ].psz = PszAlloc( m_mruRai->rgDwStr[ nn ].psz ); } } else { int type = (int)::SendMessage( m_addressTypeCombo, CB_GETCURSEL, 0, 0 ); type = (int)((type == CB_ERR)? NM_ADDR_UNKNOWN: ComboBox_GetItemData(m_addressTypeCombo, type)); ::SendMessage( GetDlgItem( m_hwnd, IDL_ACD_ADDRESS), WM_GETTEXT, CCHMAX( m_pRai->szName ), (LPARAM) m_pRai->szName ); if( (type == NM_ADDR_UNKNOWN) && bCanCallAsPhoneNumber( m_pRai->szName ) ) { type = NM_ADDR_ALIAS_E164; } m_pRai->cItems = 1; m_pRai->rgDwStr[ 0 ].dw = type; m_pRai->rgDwStr[ 0 ].psz = PszAlloc( m_pRai->szName ); } ::EndDialog( m_hwnd, IDOK ); result = true; } break; case IDCANCEL: { ::EndDialog( m_hwnd, IDCANCEL ); result = true; } break; } return( result ); } // End of CDlgAcd::onCommand. //--------------------------------------------------------------------------// // CDlgAcd::onEditChange. // //--------------------------------------------------------------------------// void CDlgAcd::onEditChange(void) { TCHAR szEdit[ CCHMAXSZ_ADDRESS ]; int cch = get_editText( szEdit, CCHMAX( szEdit ) ); EnableWindow( GetDlgItem( m_hwnd, IDOK ), (cch > 0) ); ClearRai( &m_mruRai ); } // End of CDlgAcd::onEditChange. //--------------------------------------------------------------------------// // CDlgAcd::onMruSelect. // //--------------------------------------------------------------------------// void CDlgAcd::onMruSelect ( int selection ){ int mruIndex = (int)::SendMessage( m_nameCombo, CB_GETITEMDATA, selection, 0 ); HRESULT result; RichAddressInfo * rai; if( (result = m_callMruList.GetAddress( mruIndex, &rai )) == S_OK ) { ::SetWindowText( m_nameCombo, rai->szName ); DWORD dwType = rai->rgDwStr[ 0 ].dw; // HACKHACK georgep: We know Automatic is at index 0 for (int typeIndex=ComboBox_GetCount(m_addressTypeCombo)-1; typeIndex>0; --typeIndex) { if (static_cast(ComboBox_GetItemData(m_addressTypeCombo, typeIndex)) == dwType) { break; } } ComboBox_SetCurSel(m_addressTypeCombo, typeIndex); m_mruRai = rai; } } // End of CDlgAcd::onMruSelect. //--------------------------------------------------------------------------// // CDlgAcd::newCall. // //--------------------------------------------------------------------------// void CDlgAcd::newCall ( HWND parentWindow, CConfRoom * pConfRoom ){ CDlgAcd placeCall(pConfRoom); RichAddressInfo rai; bool userAlterable; bool secure; pConfRoom->AddConferenceChangeHandler(&placeCall); pConfRoom->get_securitySettings( userAlterable, secure ); rai.szName[ 0 ] = '\0'; rai.cItems = 0; if( placeCall.doModal( parentWindow, &rai, secure ) == IDOK ) { NM_ADDR_TYPE nmType = static_cast(rai.rgDwStr[ 0 ].dw); g_pCCallto->Callto( rai.szName, // pointer to the callto url to try to place the call with... NULL, // pointer to the display name to use... nmType, // callto type to resolve this callto as... true, // the pszCallto parameter is to be interpreted as a pre-unescaped addressing component vs a full callto... &secure, // security preference, NULL for none. must be "compatible" with secure param if present... true, // whether or not save in mru... true, // whether or not to perform user interaction on errors... parentWindow, // if bUIEnabled is true this is the window to parent error/status windows to... NULL ); // out pointer to INmCall * to receive INmCall * generated by placing call... for( int nn = 0; nn < rai.cItems; nn++ ) { delete [] rai.rgDwStr[ nn ].psz; } } pConfRoom->RemoveConferenceChangeHandler(&placeCall); } // End of CDlgAcd::newCall. //--------------------------------------------------------------------------// // CDlgAcd::get_editText. // //--------------------------------------------------------------------------// int CDlgAcd::get_editText ( LPTSTR psz, int cchMax ){ ASSERT(NULL != m_nameCombo); SetEmptySz( psz ); GetWindowText( m_nameCombo, psz, cchMax ); return( TrimSz( psz ) ); } // End of get_editText. void CDlgAcd::OnCallStarted() { UpdateSecurityCheck(m_pConfRoom, m_hwnd, IDC_SECURE_CALL); // BUGBUG georgep: We get notified before the actual conference state // changes, so we need to disable manually ::EnableWindow( GetDlgItem(m_hwnd, IDC_SECURE_CALL), FALSE ); } void CDlgAcd::OnCallEnded() { UpdateSecurityCheck(m_pConfRoom, m_hwnd, IDC_SECURE_CALL); ::CheckDlgButton( m_hwnd, IDC_SECURE_CALL, m_secure ); } //--------------------------------------------------------------------------// // CEnumMRU::CEnumMRU. // //--------------------------------------------------------------------------// CEnumMRU::CEnumMRU(): RefCount( NULL ) { } // CEnumMRU::CEnumMRU. //--------------------------------------------------------------------------// // CEnumMRU::AddRef. // //--------------------------------------------------------------------------// ULONG STDMETHODCALLTYPE CEnumMRU::AddRef(void) { return( RefCount::AddRef() ); } // CEnumMRU::AddRef. //--------------------------------------------------------------------------// // CEnumMRU::Release. // //--------------------------------------------------------------------------// ULONG STDMETHODCALLTYPE CEnumMRU::Release(void) { return( RefCount::Release() ); } // CEnumMRU::Release. //--------------------------------------------------------------------------// // CEnumMRU::GetAddress. // //--------------------------------------------------------------------------// HRESULT STDMETHODCALLTYPE CEnumMRU::GetAddress ( long index, RichAddressInfo ** ppAddr ){ HRESULT result = S_FALSE; if( GetNumEntries() <= index ) { result = S_FALSE; } else { // HACKHACK georgep: Just using the Address as the display name. We // should clean this up later so we are not taking up extra memory and // registry space *ppAddr = CreateRai( GetString( index, ACD_ADDR ), (NM_ADDR_TYPE) GetDWORD( index, ACD_TYPE ), GetString( index, ACD_ADDR ) ); result = (*ppAddr == NULL)? E_OUTOFMEMORY: S_OK; } return( result ); } // CEnumMRU::GetAddress. //--------------------------------------------------------------------------// // CEnumMRU::GetRecentAddresses. // //--------------------------------------------------------------------------// HRESULT CEnumMRU::GetRecentAddresses ( IEnumRichAddressInfo ** ppEnum ){ *ppEnum = new CEnumMRU(); return( (*ppEnum == NULL)? E_OUTOFMEMORY: S_OK ); } // End of CEnumMRU::GetRecentAddresses. //--------------------------------------------------------------------------// // CEnumMRU::FreeAddress. // //--------------------------------------------------------------------------// HRESULT CEnumMRU::FreeAddress ( RichAddressInfo ** ppAddr ){ ClearRai( ppAddr ); return( S_OK ); } // End of CEnumMRU::FreeAddress. //--------------------------------------------------------------------------// // CEnumMRU::CopyAddress. // //--------------------------------------------------------------------------// HRESULT CEnumMRU::CopyAddress ( RichAddressInfo * pAddrIn, RichAddressInfo ** ppAddrOut ){ *ppAddrOut = DupRai( pAddrIn ); return( (*ppAddrOut == NULL)? E_OUTOFMEMORY: S_OK ); } // End of CEnumMRU::CopyAddress. CAcdMru::CAcdMru() : CMRUList2( _rgMruCall, CENTRYMAX_MRUCALL ) { } int CAcdMru::CompareEntry(int iItem, PMRUE pEntry) { ASSERT(NULL != pEntry); int iRet = 0; LPCTSTR psz1 = GetString(iItem, ACD_ADDR); LPCTSTR psz2 = GetString(pEntry, ACD_ADDR); ASSERT(NULL != psz1 && NULL != psz2); return(lstrcmpi(psz1, psz2)); }