forwardmgrdlg.cpp

windows mobile下

		case LINEFORWARDMODE_UNKNOWN:			strMode	= TEXT("Forward all unknownd calls");						break;
		default:								strMode	= TEXT("Unknown forwarding mode");							break;
	}
}
void CForwardMgrDlg::OnOK()
{
	ProcessCallForwarding();	

	CDialog::OnOK();
}

void CForwardMgrDlg::ProcessCallForwarding()
{
	CALLFORWARDING_INFO		sInfo[4]	= {0};
	LPLINEFORWARDLIST		pInfo		= NULL;
	LONG					lError		= 0;
	HCALL					hCall		= NULL;
	int						nSeconds	= 5;
	CString					strNumber(TEXT(""));

	int						nSel		= m_wndSeconds.GetCurSel();

	if(CB_ERR != nSel)
	{
		nSeconds	= m_wndSeconds.GetItemData(nSel);
	}

	SetCursor(LoadCursor(NULL,IDC_WAIT));

	if(BST_CHECKED == m_wndAllCalls.GetCheck())
	{
		GetDlgItemText(IDC_ALLCALLS_NUMBER,strNumber);

		sInfo[0].dwMode		= LINEFORWARDMODE_UNCOND;
		sInfo[0].nSeconds	= 0;
		sInfo[0].strNumber	= strNumber;

		pInfo	= AllocateCallForwardList(sInfo,1);

		if(pInfo)
			lError	= lineForward(m_hCellularLine,FALSE,m_dwAddressId,pInfo,0,&hCall,NULL);
	}
	else
	{
		int		nEntries	= 0;

		if(BST_CHECKED == m_wndNoAnswer.GetCheck())
		{
			GetDlgItemText(IDC_NOANSWER_NUMBER,strNumber);

			sInfo[0].dwMode		= LINEFORWARDMODE_NOANSW;
			sInfo[0].nSeconds	= nSeconds;
			sInfo[0].strNumber	= strNumber;

			++nEntries;
		}

		if(BST_CHECKED == m_wndUnAvail.GetCheck())
		{
			GetDlgItemText(IDC_UNAVAIL_NUMBER,strNumber);

			sInfo[1].dwMode		= LINEFORWARDMODE_BUSYNA;
			sInfo[1].nSeconds	= nSeconds;
			sInfo[1].strNumber	= strNumber;

			++nEntries;
		}

		if(BST_CHECKED == m_wndBusy.GetCheck())
		{
			GetDlgItemText(IDC_BUSY_NUMBER,strNumber);

			sInfo[2].dwMode		= LINEFORWARDMODE_BUSY;
			sInfo[2].nSeconds	= nSeconds;
			sInfo[2].strNumber	= strNumber;

			++nEntries;
		}

		pInfo	= AllocateCallForwardList(sInfo,nEntries);

		if(nEntries == 0)
		{
			lError	= lineForward(m_hCellularLine,FALSE,m_dwAddressId,NULL,nSeconds,&hCall,NULL);
		}
		else if(pInfo)
		{
			lError	= lineForward(m_hCellularLine,FALSE,m_dwAddressId,pInfo,nSeconds,&hCall,NULL);
		}
	}

	if(lError < 0)
	{
		CString		strError;

		strError.Format(TEXT("Error setting forward information\r\n\r\nError: %X"),lError);

		AfxMessageBox(strError);
	}

	SetCursor(LoadCursor(NULL,IDC_ARROW));
}
void CForwardMgrDlg::OnBnClickedAllCalls()
{
	EnableControls(BST_CHECKED != m_wndAllCalls.GetCheck());
}

void CForwardMgrDlg::EnableControls(BOOL bEnable)
{
	m_wndAllCalls.EnableWindow(TRUE);

	m_wndNoAnswer.EnableWindow(bEnable);
	m_wndUnAvail.EnableWindow(bEnable);
	m_wndBusy.EnableWindow(bEnable);

	if(BST_CHECKED == m_wndAllCalls.GetCheck())
	{
		m_wndNoAnswer.SetCheck(BST_UNCHECKED);
		m_wndUnAvail.SetCheck(BST_UNCHECKED);
		m_wndBusy.SetCheck(BST_UNCHECKED);
	}

	if(BST_CHECKED == m_wndNoAnswer.GetCheck())
	{
		GetDlgItem(IDC_AFTER_STATIC)->EnableWindow(TRUE);
		GetDlgItem(IDC_AFTERSECONDS)->EnableWindow(TRUE);
	}
	else
	{
		GetDlgItem(IDC_AFTER_STATIC)->EnableWindow(FALSE);
		GetDlgItem(IDC_AFTERSECONDS)->EnableWindow(FALSE);
	}

	GetDlgItem(IDC_NOANSWER_NUMBER)->EnableWindow(bEnable);
	GetDlgItem(IDC_UNAVAIL_NUMBER)->EnableWindow(bEnable);
	GetDlgItem(IDC_BUSY_NUMBER)->EnableWindow(bEnable);

	GetDlgItem(IDC_ALLCALLS_NUMBER)->EnableWindow(!bEnable);
	GetDlgItem(IDC_ALLCALLSTO_STATIC)->EnableWindow(!bEnable);
	GetDlgItem(IDC_CALLSONLY_STATIC)->EnableWindow(bEnable);
}

LPLINEFORWARDLIST CForwardMgrDlg::AllocateCallForwardList(PCALLFORWARDING_INFO pInfo,int nEntries)
{
	int					nTextLen	= 0;

	for(int nNumber=0; nNumber<nEntries; ++nNumber)
	{
		nTextLen	+= ((lstrlen(pInfo[nNumber].strNumber) + 1) * sizeof(TCHAR));
	}

	DWORD				dwSize	= (sizeof(LINEFORWARDLIST));

	dwSize	+= nTextLen;
	dwSize	+= (sizeof(LINEFORWARD) * (nEntries - 1));
								  
	LPLINEFORWARDLIST	pList		= (LPLINEFORWARDLIST)LocalAlloc(LPTR,dwSize);

	ZeroMemory(pList,dwSize);

	DWORD	dwOffset	= sizeof(LINEFORWARDLIST) + (sizeof(LINEFORWARD) * (nEntries - 1));

	pList->dwNumEntries	= nEntries;
	pList->dwTotalSize	= dwSize;
	
	for(int nNumber=0; nNumber<nEntries; ++nNumber)
	{
		pList->ForwardList[nNumber].dwCallerAddressOffset	= 0;
		pList->ForwardList[nNumber].dwCallerAddressSize		= 0;
		pList->ForwardList[nNumber].dwDestCountryCode		= 0;
		pList->ForwardList[nNumber].dwForwardMode			= pInfo[nNumber].dwMode;
		pList->ForwardList[nNumber].dwDestAddressSize		= (lstrlen(pInfo[nNumber].strNumber) + 1) * sizeof(TCHAR);
		pList->ForwardList[nNumber].dwDestAddressOffset		= dwOffset;

		wcsncpy((TCHAR*)((LPBYTE)pList + dwOffset),
				pInfo[nNumber].strNumber,
				pList->ForwardList[nNumber].dwDestAddressSize);

		dwOffset	+= ((lstrlen(pInfo[nNumber].strNumber) + 1) * sizeof(TCHAR));
	}

	return pList;
}

void CForwardMgrDlg::DisplayForwardInfo(PFORWARDINFOLIST pList)
{
	int						nCount	= pList->GetCount();
	PCALLFORWARDING_INFO	pInfo	= NULL;

	m_wndAllCalls.SetCheck(BST_UNCHECKED);
	m_wndNoAnswer.SetCheck(BST_UNCHECKED);
	m_wndUnAvail.SetCheck(BST_UNCHECKED);
	m_wndBusy.SetCheck(BST_UNCHECKED);

	CButton*	pButton		= NULL;
	UINT		uEditId		= 0;
	UINT		uSeconds	= 0;
	
	CString		strSeconds(TEXT(""));

	for(int nInfo= 0; nInfo<nCount; ++nInfo)
	{
		pInfo		= (*pList)[nInfo];
		pButton		= NULL;
		uEditId		= 0;
		uSeconds	= 0;

		strSeconds.Format(TEXT("%d Seconds"),pInfo->nSeconds);

		switch(pInfo->dwMode)
		{
			case LINEFORWARDMODE_UNCOND:
			{
				pButton		= &m_wndAllCalls;
				uEditId		= IDC_ALLCALLS_NUMBER;
				uSeconds	= 0;

				break;
			}
			case LINEFORWARDMODE_BUSY:
			{
				pButton		= &m_wndBusy;
				uEditId		= IDC_BUSY_NUMBER;
				uSeconds	= 0;

				break;
			}
			case LINEFORWARDMODE_NOANSW:
			{
				pButton		= &m_wndNoAnswer;
				uEditId		= IDC_NOANSWER_NUMBER;
				uSeconds	= pInfo->nSeconds;

				break;
			}
			case LINEFORWARDMODE_BUSYNA:
			{
				pButton		= &m_wndUnAvail;
				uEditId		= IDC_UNAVAIL_NUMBER;
				uSeconds	= 0;

				break;
			}
		}

		if(pButton)	
			pButton->SetCheck(BST_CHECKED);

		if(0 != uEditId)
			SetDlgItemText(uEditId,pInfo->strNumber);

		if(0 != uSeconds)
		{
			int	nItem	= m_wndSeconds.FindStringExact(0,strSeconds);

			if(CB_ERR != nItem)
				m_wndSeconds.SetCurSel(nItem);
		}
	}

	if(CB_ERR == m_wndSeconds.GetCurSel())
	{
		m_wndSeconds.SetCurSel(0);
	}
}

void CForwardMgrDlg::ReleaseForwardInfo(PFORWARDINFOLIST pList)
{
	int		nCount	= pList->GetCount();

	for(int nList=0; nList<nCount; ++nList)
	{
		if((*pList)[nList])
		{
			delete (*pList)[nList];

			(*pList)[nList]	= NULL;
		}
	}

	pList->RemoveAll();
}

void CForwardMgrDlg::AddSecondsToComboBox(CComboBox* pCombo)
{
	pCombo->ResetContent();

	int		nItem	= 0;

	nItem	= pCombo->AddString(TEXT("5 Seconds"));
	pCombo->SetItemData(nItem,5);

	nItem	= pCombo->AddString(TEXT("10 Seconds"));
	pCombo->SetItemData(nItem,10);

	nItem	= pCombo->AddString(TEXT("15 Seconds"));
	pCombo->SetItemData(nItem,15);

	nItem	= pCombo->AddString(TEXT("20 Seconds"));
	pCombo->SetItemData(nItem,20);

	nItem	= pCombo->AddString(TEXT("25 Seconds"));
	pCombo->SetItemData(nItem,25);

	nItem	= pCombo->AddString(TEXT("30 Seconds"));
	pCombo->SetItemData(nItem,30);
}
void CForwardMgrDlg::OnTimer(UINT_PTR nIDEvent)
{
	CDialog::OnTimer(nIDEvent);

	if(ID_TIMER_GETINFO == nIDEvent)
	{
		KillTimer(ID_TIMER_GETINFO);

		SetCursor(LoadCursor(NULL,IDC_WAIT));

		FORWARDINFOLIST		aList;

		GetAddressStatus(m_dwAddressId,&aList);
		DisplayForwardInfo(&aList);
		ReleaseForwardInfo(&aList);
		EnableControls(BST_CHECKED != m_wndAllCalls.GetCheck());

		SetCursor(LoadCursor(NULL,IDC_ARROW));
	}
}

void CForwardMgrDlg::OnBnClickedNoanswer()
{
	EnableControls(BST_CHECKED != m_wndAllCalls.GetCheck());
}