mirror of https://github.com/lianthony/NT4.0
1756 lines
43 KiB
1756 lines
43 KiB
//---------------------------------------------------------------------------
|
|
//
|
|
// Copyright (c) Microsoft Corporation 1993-1995
|
|
//
|
|
// File: ring.c
|
|
//
|
|
// This files contains the dialog code for the Voice settings
|
|
// property pages.
|
|
//
|
|
// History:
|
|
// 07-05-95 ScottH Created
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
#include "proj.h" // common headers
|
|
|
|
#if defined(WIN95) && defined(CS_HELP)
|
|
#include "..\..\..\..\win\core\inc\help.h"
|
|
#endif
|
|
|
|
#define CX_PATTERN 40
|
|
#define CY_PATTERN 5
|
|
|
|
typedef struct tagRING
|
|
{
|
|
HWND hdlg; // dialog handle
|
|
LPMODEMINFO pmi; // modeminfo struct passed into dialog
|
|
|
|
HBITMAP hbmStrip;
|
|
HDC hdcStrip;
|
|
HFONT hfont;
|
|
int cyText;
|
|
|
|
} RING, FAR * PRING;
|
|
|
|
|
|
typedef struct tagRINGPAT
|
|
{
|
|
DWORD dwPattern;
|
|
LPARAM lParam;
|
|
} RINGPAT, FAR * PRINGPAT;
|
|
|
|
static RINGPAT s_rgrp[] =
|
|
{
|
|
{ DRP_NONE, 0 },
|
|
{ DRP_SHORT, 0 },
|
|
{ DRP_LONG, 0 },
|
|
{ DRP_SHORTSHORT, 0 },
|
|
{ DRP_SHORTLONG, 0 },
|
|
{ DRP_LONGSHORT, 0 },
|
|
{ DRP_LONGLONG, 0 },
|
|
{ DRP_SHORTSHORTLONG, 0 },
|
|
{ DRP_SHORTLONGSHORT, 0 },
|
|
{ DRP_LONGSHORTSHORT, 0 },
|
|
{ DRP_LONGSHORTLONG, 0 },
|
|
};
|
|
|
|
#pragma data_seg(DATASEG_READONLY)
|
|
|
|
const static UINT c_rgidcPattern[] =
|
|
{
|
|
IDC_ADDR_PRI,
|
|
IDC_ADDR1,
|
|
IDC_ADDR2,
|
|
IDC_ADDR3,
|
|
IDC_PRI_CALLERS,
|
|
IDC_CALLBACK,
|
|
};
|
|
const static UINT c_rgidcTypeOfCalls[] =
|
|
{
|
|
IDC_TYPE_ADDR_PRI,
|
|
IDC_TYPE_ADDR1,
|
|
IDC_TYPE_ADDR2,
|
|
IDC_TYPE_ADDR3,
|
|
IDC_TYPE_PRI_CALLERS,
|
|
IDC_TYPE_CALLBACK,
|
|
};
|
|
|
|
static DWORD c_rgdwCheapPatterns[] =
|
|
{
|
|
DRP_SINGLE,
|
|
DRP_DOUBLE,
|
|
DRP_TRIPLE,
|
|
};
|
|
|
|
const static UINT c_rgidcTypeOfCheapCalls[] =
|
|
{
|
|
IDC_TYPE_RING1,
|
|
IDC_TYPE_RING2,
|
|
IDC_TYPE_RING3,
|
|
};
|
|
|
|
TCHAR const FAR c_szUnimdmHelpFile[] = TEXT("unimdm.hlp");
|
|
|
|
#pragma data_seg()
|
|
|
|
|
|
#define Ring_GetPtr(hwnd) (PRING)GetWindowLong(hwnd, DWL_USER)
|
|
#define Ring_SetPtr(hwnd, lp) (PRING)SetWindowLong(hwnd, DWL_USER, (LONG)(lp))
|
|
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// Voice settings dialog code
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Initialize the bitmap strip
|
|
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
void PRIVATE Ring_InitStrip(
|
|
PRING this,
|
|
HDC hdc)
|
|
{
|
|
ASSERT(hdc);
|
|
|
|
this->hbmStrip = LoadBitmap(g_hinst, MAKEINTRESOURCE(IDB_PATTERNS));
|
|
ASSERT(this->hbmStrip);
|
|
|
|
this->hdcStrip = CreateCompatibleDC(hdc);
|
|
if (this->hdcStrip)
|
|
{
|
|
SelectObject(this->hdcStrip, this->hbmStrip);
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Initialize the specified Pattern combobox.
|
|
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
void PRIVATE Ring_InitPattern(
|
|
PRING this,
|
|
HWND hwndCB,
|
|
DWORD dwPattern)
|
|
{
|
|
int i;
|
|
int iSel = 0;
|
|
int n;
|
|
|
|
// Fill the listbox
|
|
for (i = 0; i < ARRAY_ELEMENTS(s_rgrp); i++)
|
|
{
|
|
n = ComboBox_AddString(hwndCB, &s_rgrp[i]);
|
|
|
|
// Keep our eyes peeled for the selected type
|
|
if (dwPattern == s_rgrp[i].dwPattern)
|
|
{
|
|
iSel = n;
|
|
}
|
|
}
|
|
|
|
ComboBox_SetCurSel(hwndCB, iSel);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Initialize the specified Type of Call combobox.
|
|
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
void PRIVATE Ring_InitTypeOfCall(
|
|
PRING this,
|
|
HWND hwndCB,
|
|
DWORD dwType)
|
|
{
|
|
#pragma data_seg(DATASEG_READONLY)
|
|
static const struct
|
|
{
|
|
UINT ids;
|
|
DWORD dwType; // DRT_*
|
|
} s_rgTypes[] =
|
|
{
|
|
{ IDS_UNSPECIFIED, DRT_UNSPECIFIED },
|
|
{ IDS_DATA, DRT_DATA },
|
|
{ IDS_FAX, DRT_FAX },
|
|
{ IDS_VOICE, DRT_VOICE },
|
|
};
|
|
#pragma data_seg()
|
|
|
|
int i;
|
|
int iSel = 0;
|
|
int n;
|
|
TCHAR sz[MAXMEDLEN];
|
|
|
|
// Fill the listbox
|
|
for (i = 0; i < ARRAY_ELEMENTS(s_rgTypes); i++)
|
|
{
|
|
n = ComboBox_AddString(hwndCB, SzFromIDS(g_hinst, s_rgTypes[i].ids, sz, SIZECHARS(sz)));
|
|
ComboBox_SetItemData(hwndCB, n, s_rgTypes[i].dwType);
|
|
|
|
// Keep our eyes peeled for the selected type
|
|
if (dwType == s_rgTypes[i].dwType)
|
|
{
|
|
iSel = n;
|
|
}
|
|
}
|
|
|
|
ComboBox_SetCurSel(hwndCB, iSel);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Enable/disable all the controls
|
|
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
void PRIVATE Ring_EnableControls(
|
|
PRING this,
|
|
BOOL bEnable)
|
|
{
|
|
HWND hwnd = this->hdlg;
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_LBL_ADDR_PRI), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ADDR_PRI), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_TYPE_ADDR_PRI), bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_LBL_ADDR1), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ADDR1), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_TYPE_ADDR1), bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_LBL_ADDR2), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ADDR2), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_TYPE_ADDR2), bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_LBL_ADDR3), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ADDR3), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_TYPE_ADDR3), bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_LBL_PRI_CALLERS), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_PRI_CALLERS), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_TYPE_PRI_CALLERS), bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_LBL_CALLBACK), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_CALLBACK), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_TYPE_CALLBACK), bEnable);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_INITDIALOG Handler
|
|
Returns: FALSE when we assign the control focus
|
|
Cond: --
|
|
*/
|
|
BOOL PRIVATE Ring_OnInitDialog(
|
|
PRING this,
|
|
HWND hwndFocus,
|
|
LPARAM lParam) // expected to be PROPSHEETINFO
|
|
{
|
|
LPPROPSHEETPAGE lppsp = (LPPROPSHEETPAGE)lParam;
|
|
HWND hwnd = this->hdlg;
|
|
HWND hwndCtl;
|
|
LPDWORD lpdw;
|
|
BOOL bEnable;
|
|
int i;
|
|
PVOICEFEATURES pvs;
|
|
HDC hdc;
|
|
LOGFONT lf;
|
|
|
|
ASSERT((LPTSTR)lppsp->lParam);
|
|
|
|
this->pmi = (LPMODEMINFO)lppsp->lParam;
|
|
pvs = &this->pmi->pglobal->vs;
|
|
|
|
// Determine some font things
|
|
|
|
SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lf), &lf, FALSE);
|
|
this->hfont = CreateFontIndirect(&lf);
|
|
|
|
// Create bitmap strip
|
|
|
|
hdc = GetDC(hwnd);
|
|
if (hdc)
|
|
{
|
|
Ring_InitStrip(this, hdc);
|
|
ReleaseDC(hwnd, hdc);
|
|
}
|
|
|
|
// Enable/disable controls
|
|
|
|
bEnable = IsFlagSet(this->pmi->pglobal->vs.dwFlags, VSF_DIST_RING);
|
|
|
|
Button_SetCheck(GetDlgItem(hwnd, IDC_RING_CHECK), bEnable);
|
|
Ring_EnableControls(this, bEnable);
|
|
|
|
// Initialize controls
|
|
|
|
for (i = 0; i < ARRAY_ELEMENTS(c_rgidcPattern); i++)
|
|
{
|
|
hwndCtl = GetDlgItem(hwnd, c_rgidcPattern[i]);
|
|
lpdw = &pvs->DistRing[i].dwPattern;
|
|
|
|
Ring_InitPattern(this, hwndCtl, *lpdw);
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_ELEMENTS(c_rgidcTypeOfCalls); i++)
|
|
{
|
|
hwndCtl = GetDlgItem(hwnd, c_rgidcTypeOfCalls[i]);
|
|
lpdw = &pvs->DistRing[i].dwMediaType;
|
|
|
|
Ring_InitTypeOfCall(this, hwndCtl, *lpdw);
|
|
}
|
|
|
|
return TRUE; // default initial focus
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_COMMAND Handler
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
void PRIVATE Ring_OnCommand(
|
|
PRING this,
|
|
int id,
|
|
HWND hwndCtl,
|
|
UINT uNotifyCode)
|
|
{
|
|
BOOL bCheck;
|
|
|
|
switch (id)
|
|
{
|
|
case IDC_RING_CHECK:
|
|
bCheck = Button_GetCheck(hwndCtl);
|
|
Ring_EnableControls(this, bCheck);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Validate the user's settings.
|
|
|
|
The ring patterns must be unique, except that
|
|
any/all may be set to DRP_NONE.
|
|
|
|
Returns: TRUE if valid
|
|
|
|
Cond: --
|
|
*/
|
|
BOOL PRIVATE Ring_ValidateSettings(
|
|
PRING this)
|
|
{
|
|
HWND hwnd = this->hdlg;
|
|
int i;
|
|
int iSel;
|
|
HWND hwndCtl;
|
|
PRINGPAT prp;
|
|
|
|
for (i = 0; i < ARRAY_ELEMENTS(s_rgrp); i++)
|
|
{
|
|
// Initialize lParam to 0
|
|
s_rgrp[i].lParam = 0;
|
|
}
|
|
|
|
// Get the ring pattern settings
|
|
|
|
for (i = 0; i < ARRAY_ELEMENTS(c_rgidcPattern); i++)
|
|
{
|
|
hwndCtl = GetDlgItem(hwnd, c_rgidcPattern[i]);
|
|
|
|
iSel = ComboBox_GetCurSel(hwndCtl);
|
|
ASSERT(LB_ERR != iSel);
|
|
|
|
ComboBox_GetLBText(hwndCtl, iSel, &prp);
|
|
|
|
// Is this pattern already selected,
|
|
// and is it something other than none?
|
|
if (DRP_NONE != prp->dwPattern && prp->lParam)
|
|
{
|
|
// Yes; can't have duplicate values
|
|
MsgBox(g_hinst,
|
|
hwnd,
|
|
MAKEINTRESOURCE(IDS_ERR_DUP_PATTERN),
|
|
MAKEINTRESOURCE(IDS_CAP_RING),
|
|
NULL,
|
|
MB_ERROR);
|
|
|
|
// Set the focus on the offending control
|
|
PostMessage(hwnd, WM_NEXTDLGCTL, (WPARAM)hwndCtl, (LPARAM)TRUE);
|
|
return FALSE;
|
|
}
|
|
prp->lParam = TRUE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: PSN_APPLY handler
|
|
|
|
Returns: TRUE if validation succeeded
|
|
FALSE if not
|
|
|
|
Cond: --
|
|
*/
|
|
BOOL PRIVATE Ring_OnApply(
|
|
PRING this)
|
|
{
|
|
BOOL bRet;
|
|
HWND hwnd = this->hdlg;
|
|
HWND hwndCtl;
|
|
LPDWORD lpdw;
|
|
int i;
|
|
int iSel;
|
|
PVOICEFEATURES pvs = &this->pmi->pglobal->vs;
|
|
PRINGPAT prp;
|
|
|
|
bRet = Ring_ValidateSettings(this);
|
|
|
|
// Are the user's settings valid?
|
|
if (bRet)
|
|
{
|
|
// Yes
|
|
if (Button_GetCheck(GetDlgItem(hwnd, IDC_RING_CHECK)))
|
|
{
|
|
SetFlag(pvs->dwFlags, VSF_DIST_RING);
|
|
}
|
|
else
|
|
{
|
|
ClearFlag(pvs->dwFlags, VSF_DIST_RING);
|
|
}
|
|
|
|
|
|
// Get the ring pattern settings
|
|
|
|
for (i = 0; i < ARRAY_ELEMENTS(c_rgidcPattern); i++)
|
|
{
|
|
hwndCtl = GetDlgItem(hwnd, c_rgidcPattern[i]);
|
|
lpdw = &pvs->DistRing[i].dwPattern;
|
|
|
|
iSel = ComboBox_GetCurSel(hwndCtl);
|
|
ASSERT(LB_ERR != iSel);
|
|
|
|
ComboBox_GetLBText(hwndCtl, iSel, &prp);
|
|
|
|
*lpdw = prp->dwPattern;
|
|
}
|
|
|
|
// Get the type of call settings
|
|
|
|
for (i = 0; i < ARRAY_ELEMENTS(c_rgidcTypeOfCalls); i++)
|
|
{
|
|
hwndCtl = GetDlgItem(hwnd, c_rgidcTypeOfCalls[i]);
|
|
lpdw = &pvs->DistRing[i].dwMediaType;
|
|
|
|
iSel = ComboBox_GetCurSel(hwndCtl);
|
|
ASSERT(LB_ERR != iSel);
|
|
|
|
*lpdw = ComboBox_GetItemData(hwndCtl, iSel);
|
|
}
|
|
|
|
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_NOTIFY handler
|
|
Returns: varies
|
|
Cond: --
|
|
*/
|
|
LRESULT PRIVATE Ring_OnNotify(
|
|
PRING this,
|
|
int idFrom,
|
|
NMHDR FAR * lpnmhdr)
|
|
{
|
|
LRESULT lRet = 0;
|
|
|
|
switch (lpnmhdr->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
break;
|
|
|
|
case PSN_KILLACTIVE:
|
|
// N.b. This message is not sent if user clicks Cancel!
|
|
// N.b. This message is sent prior to PSN_APPLY
|
|
//
|
|
break;
|
|
|
|
case PSN_APPLY:
|
|
lRet = Ring_OnApply(this) ? PSNRET_NOERROR : PSNRET_INVALID;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return lRet;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_DESTROY handler
|
|
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
void PRIVATE Ring_OnDestroy(
|
|
PRING this)
|
|
{
|
|
if (this->hdcStrip)
|
|
DeleteDC(this->hdcStrip);
|
|
|
|
if (this->hbmStrip)
|
|
DeleteObject(this->hbmStrip);
|
|
|
|
if (this->hfont)
|
|
DeleteFont(this->hfont);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_MEASUREITEM handler
|
|
Returns: --
|
|
|
|
Cond: !!! WM_MEASUREITEM is received before WM_INITDIALOG !!!
|
|
|
|
The contents of 'this' will be uninitialized.
|
|
*/
|
|
void PRIVATE Ring_OnMeasureItem(
|
|
PRING this,
|
|
LPMEASUREITEMSTRUCT lpmis)
|
|
{
|
|
HWND hwnd = this->hdlg;
|
|
HDC hdc;
|
|
|
|
ASSERT(ODT_COMBOBOX == lpmis->CtlType);
|
|
|
|
hdc = GetDC(hwnd);
|
|
if (hdc)
|
|
{
|
|
TEXTMETRIC tm;
|
|
|
|
GetTextMetrics(hdc, &tm);
|
|
lpmis->itemHeight = max(tm.tmHeight, CY_PATTERN);
|
|
|
|
ReleaseDC(hwnd, hdc);
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_DRAWITEM handler
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
void PRIVATE Ring_OnDrawCBItem(
|
|
PRING this,
|
|
const DRAWITEMSTRUCT FAR * lpcdis)
|
|
{
|
|
HWND hwnd = this->hdlg;
|
|
PRINGPAT prp = (PRINGPAT)lpcdis->itemData;
|
|
|
|
ASSERT(ODT_COMBOBOX == lpcdis->CtlType);
|
|
ASSERT(prp);
|
|
|
|
if (prp)
|
|
{
|
|
HDC hdc = lpcdis->hDC;
|
|
RECT rc = lpcdis->rcItem;
|
|
RECT rcFrame;
|
|
POINT ptSav;
|
|
int x;
|
|
int y;
|
|
int nBkMode;
|
|
COLORREF crText;
|
|
COLORREF crBk;
|
|
COLORREF crTextSav;
|
|
COLORREF crBkSav;
|
|
|
|
ASSERT(hdc);
|
|
|
|
SetViewportOrgEx(hdc, rc.left, rc.top, &ptSav);
|
|
|
|
rcFrame.top = 0;
|
|
rcFrame.left = 0;
|
|
rcFrame.bottom = rc.bottom - rc.top;
|
|
rcFrame.right = rc.right - rc.left;
|
|
|
|
// Set the colors
|
|
|
|
nBkMode = SetBkMode(hdc, TRANSPARENT);
|
|
|
|
TextAndBkCr(lpcdis, &crText, &crBk);
|
|
crTextSav = SetTextColor(hdc, crText);
|
|
crBkSav = SetBkColor(hdc, crBk);
|
|
|
|
// Do we need to redraw everything?
|
|
if (IsFlagSet(lpcdis->itemAction, ODA_DRAWENTIRE) ||
|
|
IsFlagSet(lpcdis->itemAction, ODA_SELECT))
|
|
{
|
|
// Yes
|
|
TCHAR sz[MAXSHORTLEN];
|
|
LPTSTR psz = sz;
|
|
int cch;
|
|
HFONT hfontSav;
|
|
|
|
// Show bitmap or text?
|
|
if (DRP_NONE == prp->dwPattern)
|
|
{
|
|
// Text
|
|
hfontSav = SelectFont(hdc, this->hfont);
|
|
SzFromIDS(g_hinst, IDS_AUTOMATIC, sz, SIZECHARS(sz));
|
|
cch = lstrlen(sz);
|
|
}
|
|
else
|
|
{
|
|
// Bitmap
|
|
hfontSav = NULL;
|
|
*psz = 0;
|
|
cch = 0;
|
|
}
|
|
|
|
ASSERT(rc.right - rc.left >= CX_PATTERN);
|
|
ASSERT(rc.bottom - rc.top >= CY_PATTERN);
|
|
|
|
x = (rc.right - rc.left - CX_PATTERN) / 2;
|
|
y = (rc.bottom - rc.top - CY_PATTERN) / 2;
|
|
|
|
// Fill background (with optional text)
|
|
ExtTextOut(hdc, 2, 2, ETO_OPAQUE, &rcFrame, psz, cch, NULL);
|
|
|
|
if (DRP_NONE != prp->dwPattern)
|
|
{
|
|
// Draw bitmap
|
|
BitBlt(hdc, x, y, CX_PATTERN, CY_PATTERN,
|
|
this->hdcStrip, ((int)prp->dwPattern - 1) * CX_PATTERN, 0,
|
|
SRCCOPY);
|
|
}
|
|
|
|
if (hfontSav)
|
|
SelectFont(hdc, hfontSav);
|
|
}
|
|
|
|
// Draw the caret?
|
|
if (IsFlagSet(lpcdis->itemAction, ODA_FOCUS) ||
|
|
IsFlagSet(lpcdis->itemState, ODS_FOCUS))
|
|
{
|
|
// Yes
|
|
DrawFocusRect(hdc, &rcFrame);
|
|
}
|
|
|
|
// Clean up
|
|
SetTextColor(hdc, crTextSav);
|
|
SetBkColor(hdc, crBkSav);
|
|
SetBkMode(hdc, nBkMode);
|
|
SetViewportOrgEx(hdc, ptSav.x, ptSav.y, NULL);
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_DRAWITEM handler
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
void PRIVATE Ring_OnDrawStaticItem(
|
|
PRING this,
|
|
const DRAWITEMSTRUCT FAR * lpcdis)
|
|
{
|
|
HWND hwnd = this->hdlg;
|
|
HDC hdc = lpcdis->hDC;
|
|
RECT rc = lpcdis->rcItem;
|
|
int x;
|
|
int y;
|
|
int nBkMode;
|
|
COLORREF crText;
|
|
COLORREF crBk;
|
|
COLORREF crTextSav;
|
|
COLORREF crBkSav;
|
|
|
|
ASSERT(ODT_STATIC == lpcdis->CtlType);
|
|
ASSERT(hdc);
|
|
|
|
// Set the colors
|
|
|
|
nBkMode = SetBkMode(hdc, TRANSPARENT);
|
|
|
|
TextAndBkCr(lpcdis, &crText, &crBk);
|
|
crTextSav = SetTextColor(hdc, crText);
|
|
crBkSav = SetBkColor(hdc, crBk);
|
|
|
|
ASSERT(rc.right - rc.left >= CX_PATTERN);
|
|
ASSERT(rc.bottom - rc.top >= CY_PATTERN);
|
|
|
|
x = (rc.right - rc.left - CX_PATTERN) / 2;
|
|
y = (rc.bottom - rc.top - CY_PATTERN) / 2;
|
|
|
|
// Fill background (with optional text)
|
|
ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rc, TEXT(""), 0, NULL);
|
|
|
|
// Draw bitmap
|
|
BitBlt(hdc, x, y, CX_PATTERN, CY_PATTERN,
|
|
this->hdcStrip, (int)(DRP_LONG - 1) * CX_PATTERN, 0,
|
|
SRCCOPY);
|
|
|
|
// Clean up
|
|
SetTextColor(hdc, crTextSav);
|
|
SetBkColor(hdc, crBkSav);
|
|
SetBkMode(hdc, nBkMode);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_DRAWITEM handler
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
void PRIVATE Ring_OnDrawItem(
|
|
PRING this,
|
|
const DRAWITEMSTRUCT FAR * lpcdis)
|
|
{
|
|
switch (lpcdis->CtlType)
|
|
{
|
|
case ODT_COMBOBOX:
|
|
Ring_OnDrawCBItem(this, lpcdis);
|
|
break;
|
|
|
|
case ODT_STATIC:
|
|
Ring_OnDrawStaticItem(this, lpcdis);
|
|
break;
|
|
|
|
default:
|
|
ASSERT(0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_DELETEITEM handler
|
|
Returns: --
|
|
|
|
Cond: !!! WM_DELETEITEM is received after WM_DESTROY !!!
|
|
|
|
*/
|
|
void Ring_OnDeleteItem(
|
|
PRING this,
|
|
const DELETEITEMSTRUCT FAR * lpcdis)
|
|
{
|
|
PRINGPAT prp = (PRINGPAT)lpcdis->itemData;
|
|
|
|
ASSERT(NULL == this); // this will be NULL
|
|
|
|
ASSERT(ODT_COMBOBOX == lpcdis->CtlType);
|
|
ASSERT(prp);
|
|
}
|
|
|
|
|
|
static BOOL s_bRingRecurse = FALSE;
|
|
|
|
LRESULT INLINE Ring_DefProc(
|
|
HWND hDlg,
|
|
UINT msg,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
ENTER_X()
|
|
{
|
|
s_bRingRecurse = TRUE;
|
|
}
|
|
LEAVE_X()
|
|
|
|
return DefDlgProc(hDlg, msg, wParam, lParam);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Real dialog proc
|
|
Returns: varies
|
|
Cond: --
|
|
*/
|
|
LRESULT Ring_DlgProc(
|
|
PRING this,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
#ifdef CS_HELP
|
|
// UE used the control IDs as help IDs. To prevent mix-ups in
|
|
// the future (ie, when the control IDs change), here are the
|
|
// help IDs.
|
|
#define IDH_UNI_RING_SERVICES 1069
|
|
#define IDH_UNI_RING_LBL_ADDR_PRI 1070
|
|
#define IDH_UNI_RING_ADDR_PRI 1073
|
|
#define IDH_UNI_RING_TYPE_ADDR_PRI 1082
|
|
#define IDH_UNI_RING_LBL_ADDR1 1071
|
|
#define IDH_UNI_RING_ADDR1 1074
|
|
#define IDH_UNI_RING_TYPE_ADDR1 1083
|
|
#define IDH_UNI_RING_LBL_ADDR2 1072
|
|
#define IDH_UNI_RING_ADDR2 1075
|
|
#define IDH_UNI_RING_TYPE_ADDR2 1084
|
|
#define IDH_UNI_RING_LBL_ADDR3 1076
|
|
#define IDH_UNI_RING_ADDR3 1077
|
|
#define IDH_UNI_RING_TYPE_ADDR3 1085
|
|
#define IDH_UNI_RING_LBL_PRI_CALLERS 1078
|
|
#define IDH_UNI_RING_PRI_CALLERS 1079
|
|
#define IDH_UNI_RING_TYPE_PRI_CALLERS 1086
|
|
#define IDH_UNI_RING_LBL_CALLBACK 1080
|
|
#define IDH_UNI_RING_CALLBACK 1081
|
|
#define IDH_UNI_RING_TYPE_CALLBACK 1087
|
|
#pragma data_seg(DATASEG_READONLY)
|
|
const static DWORD rgHelpIDs[] = {
|
|
IDC_RING_CHECK, IDH_UNI_RING_SERVICES,
|
|
IDC_LBL_ADDR_PRI, IDH_UNI_RING_LBL_ADDR_PRI,
|
|
IDC_ADDR_PRI, IDH_UNI_RING_ADDR_PRI,
|
|
IDC_TYPE_ADDR_PRI, IDH_UNI_RING_TYPE_ADDR_PRI,
|
|
IDC_LBL_ADDR1, IDH_UNI_RING_LBL_ADDR1,
|
|
IDC_ADDR1, IDH_UNI_RING_ADDR1,
|
|
IDC_TYPE_ADDR1, IDH_UNI_RING_TYPE_ADDR1,
|
|
IDC_LBL_ADDR2, IDH_UNI_RING_LBL_ADDR2,
|
|
IDC_ADDR2, IDH_UNI_RING_ADDR2,
|
|
IDC_TYPE_ADDR2, IDH_UNI_RING_TYPE_ADDR2,
|
|
IDC_LBL_ADDR3, IDH_UNI_RING_LBL_ADDR3,
|
|
IDC_ADDR3, IDH_UNI_RING_ADDR3,
|
|
IDC_TYPE_ADDR3, IDH_UNI_RING_TYPE_ADDR3,
|
|
IDC_LBL_PRI_CALLERS, IDH_UNI_RING_LBL_PRI_CALLERS,
|
|
IDC_PRI_CALLERS, IDH_UNI_RING_PRI_CALLERS,
|
|
IDC_TYPE_PRI_CALLERS, IDH_UNI_RING_TYPE_PRI_CALLERS,
|
|
IDC_LBL_CALLBACK, IDH_UNI_RING_LBL_CALLBACK,
|
|
IDC_CALLBACK, IDH_UNI_RING_CALLBACK,
|
|
IDC_TYPE_CALLBACK, IDH_UNI_RING_TYPE_CALLBACK,
|
|
0, 0 };
|
|
#pragma data_seg()
|
|
#endif
|
|
|
|
switch (message)
|
|
{
|
|
HANDLE_MSG(this, WM_INITDIALOG, Ring_OnInitDialog);
|
|
HANDLE_MSG(this, WM_COMMAND, Ring_OnCommand);
|
|
HANDLE_MSG(this, WM_NOTIFY, Ring_OnNotify);
|
|
HANDLE_MSG(this, WM_DESTROY, Ring_OnDestroy);
|
|
|
|
HANDLE_MSG(this, WM_MEASUREITEM, Ring_OnMeasureItem);
|
|
HANDLE_MSG(this, WM_DRAWITEM, Ring_OnDrawItem);
|
|
HANDLE_MSG(this, WM_DELETEITEM, Ring_OnDeleteItem);
|
|
|
|
#ifdef CS_HELP
|
|
case WM_HELP:
|
|
WinHelp(((LPHELPINFO)lParam)->hItemHandle, c_szUnimdmHelpFile, HELP_WM_HELP, (DWORD)(LPVOID)rgHelpIDs);
|
|
return 0;
|
|
|
|
case WM_CONTEXTMENU:
|
|
WinHelp((HWND)wParam, c_szUnimdmHelpFile, HELP_CONTEXTMENU, (DWORD)(LPVOID)rgHelpIDs);
|
|
return 0;
|
|
#endif
|
|
|
|
default:
|
|
return Ring_DefProc(this->hdlg, message, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Dialog Wrapper
|
|
Returns: varies
|
|
Cond: --
|
|
*/
|
|
BOOL CALLBACK Ring_WrapperProc(
|
|
HWND hDlg, // std params
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
PRING this;
|
|
|
|
// Cool windowsx.h dialog technique. For full explanation, see
|
|
// WINDOWSX.TXT. This supports multiple-instancing of dialogs.
|
|
//
|
|
ENTER_X()
|
|
{
|
|
if (s_bRingRecurse)
|
|
{
|
|
s_bRingRecurse = FALSE;
|
|
LEAVE_X()
|
|
return FALSE;
|
|
}
|
|
}
|
|
LEAVE_X()
|
|
|
|
this = Ring_GetPtr(hDlg);
|
|
if (this == NULL)
|
|
{
|
|
// (WM_SETFONT is the first message received by dialogs)
|
|
if (WM_SETFONT == message)
|
|
{
|
|
this = (PRING)LocalAlloc(LPTR, sizeof(RING));
|
|
if (!this)
|
|
{
|
|
MsgBox(g_hinst,
|
|
hDlg,
|
|
MAKEINTRESOURCE(IDS_OOM_SETTINGS),
|
|
MAKEINTRESOURCE(IDS_CAP_RING),
|
|
NULL,
|
|
MB_ERROR);
|
|
EndDialog(hDlg, IDCANCEL);
|
|
return (BOOL)Ring_DefProc(hDlg, message, wParam, lParam);
|
|
}
|
|
this->hdlg = hDlg;
|
|
Ring_SetPtr(hDlg, this);
|
|
}
|
|
else
|
|
{
|
|
return (BOOL)Ring_DefProc(hDlg, message, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
if (message == WM_DESTROY)
|
|
{
|
|
Ring_DlgProc(this, message, wParam, lParam);
|
|
LocalFree((HLOCAL)OFFSETOF(this));
|
|
Ring_SetPtr(hDlg, NULL);
|
|
return 0;
|
|
}
|
|
|
|
return SetDlgMsgResult(hDlg, message, Ring_DlgProc(this, message, wParam, lParam));
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// Cheap ring dialog code
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
#define CheapRing_GetPtr(hwnd) (PRING)GetWindowLong(hwnd, DWL_USER)
|
|
#define CheapRing_SetPtr(hwnd, lp) (PRING)SetWindowLong(hwnd, DWL_USER, (LONG)(lp))
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Initialize the specified Type of Call combobox.
|
|
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
void PRIVATE CheapRing_InitTypeOfCall(
|
|
PRING this,
|
|
HWND hwndCB,
|
|
DWORD dwType)
|
|
{
|
|
#pragma data_seg(DATASEG_READONLY)
|
|
static const struct
|
|
{
|
|
UINT ids;
|
|
DWORD dwType; // DRT_*
|
|
} s_rgTypes[] =
|
|
{
|
|
{ IDS_UNSPECIFIED, DRT_UNSPECIFIED },
|
|
{ IDS_DATA, DRT_DATA },
|
|
{ IDS_FAX, DRT_FAX },
|
|
{ IDS_VOICE, DRT_VOICE },
|
|
};
|
|
#pragma data_seg()
|
|
|
|
int i;
|
|
int iSel = 0;
|
|
int n;
|
|
TCHAR sz[MAXMEDLEN];
|
|
|
|
// Fill the listbox
|
|
for (i = 0; i < ARRAY_ELEMENTS(s_rgTypes); i++)
|
|
{
|
|
n = ComboBox_AddString(hwndCB, SzFromIDS(g_hinst, s_rgTypes[i].ids, sz, SIZECHARS(sz)));
|
|
ComboBox_SetItemData(hwndCB, n, s_rgTypes[i].dwType);
|
|
|
|
// Keep our eyes peeled for the selected type
|
|
if (dwType == s_rgTypes[i].dwType)
|
|
{
|
|
iSel = n;
|
|
}
|
|
}
|
|
|
|
ComboBox_SetCurSel(hwndCB, iSel);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Enable/disable all the controls
|
|
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
void PRIVATE CheapRing_EnableControls(
|
|
PRING this,
|
|
BOOL bEnable)
|
|
{
|
|
HWND hwnd = this->hdlg;
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_LBL_RING1), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_TYPE_RING1), bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_LBL_RING2), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_TYPE_RING2), bEnable);
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_LBL_RING3), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_TYPE_RING3), bEnable);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_INITDIALOG Handler
|
|
Returns: FALSE when we assign the control focus
|
|
Cond: --
|
|
*/
|
|
BOOL PRIVATE CheapRing_OnInitDialog(
|
|
PRING this,
|
|
HWND hwndFocus,
|
|
LPARAM lParam) // expected to be PROPSHEETINFO
|
|
{
|
|
|
|
LPPROPSHEETPAGE lppsp = (LPPROPSHEETPAGE)lParam;
|
|
HWND hwnd = this->hdlg;
|
|
HWND hwndCtl;
|
|
LPDWORD lpdw;
|
|
BOOL bEnable;
|
|
int i;
|
|
PVOICEFEATURES pvs;
|
|
|
|
ASSERT((LPTSTR)lppsp->lParam);
|
|
|
|
this->pmi = (LPMODEMINFO)lppsp->lParam;
|
|
pvs = &this->pmi->pglobal->vs;
|
|
|
|
// Enable/disable controls
|
|
|
|
bEnable = IsFlagSet(this->pmi->pglobal->vs.dwFlags, VSF_DIST_RING);
|
|
|
|
Button_SetCheck(GetDlgItem(hwnd, IDC_RING_CHECK), bEnable);
|
|
CheapRing_EnableControls(this, bEnable);
|
|
|
|
// Initialize controls
|
|
|
|
for (i = 0; i < ARRAY_ELEMENTS(c_rgidcTypeOfCheapCalls); i++)
|
|
{
|
|
hwndCtl = GetDlgItem(hwnd, c_rgidcTypeOfCheapCalls[i]);
|
|
lpdw = &pvs->DistRing[i].dwMediaType;
|
|
|
|
CheapRing_InitTypeOfCall(this, hwndCtl, *lpdw);
|
|
}
|
|
|
|
return TRUE; // default initial focus
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_COMMAND Handler
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
void PRIVATE CheapRing_OnCommand(
|
|
PRING this,
|
|
int id,
|
|
HWND hwndCtl,
|
|
UINT uNotifyCode)
|
|
{
|
|
BOOL bCheck;
|
|
|
|
switch (id)
|
|
{
|
|
case IDC_RING_CHECK:
|
|
bCheck = Button_GetCheck(hwndCtl);
|
|
CheapRing_EnableControls(this, bCheck);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: PSN_APPLY handler
|
|
|
|
Returns: TRUE if validation succeeded
|
|
FALSE if not
|
|
|
|
Cond: --
|
|
*/
|
|
BOOL PRIVATE CheapRing_OnApply(
|
|
PRING this)
|
|
{
|
|
HWND hwnd = this->hdlg;
|
|
HWND hwndCtl;
|
|
LPDWORD lpdw;
|
|
int i;
|
|
int iSel;
|
|
PVOICEFEATURES pvs = &this->pmi->pglobal->vs;
|
|
|
|
if (Button_GetCheck(GetDlgItem(hwnd, IDC_RING_CHECK)))
|
|
{
|
|
SetFlag(pvs->dwFlags, VSF_DIST_RING);
|
|
}
|
|
else
|
|
{
|
|
ClearFlag(pvs->dwFlags, VSF_DIST_RING);
|
|
}
|
|
|
|
|
|
// Get the ring pattern settings
|
|
|
|
for (i = 0; i < ARRAY_ELEMENTS(c_rgdwCheapPatterns); i++)
|
|
{
|
|
pvs->DistRing[i].dwPattern = c_rgdwCheapPatterns[i];
|
|
}
|
|
|
|
// Get the type of call settings
|
|
|
|
for (i = 0; i < ARRAY_ELEMENTS(c_rgidcTypeOfCheapCalls); i++)
|
|
{
|
|
hwndCtl = GetDlgItem(hwnd, c_rgidcTypeOfCheapCalls[i]);
|
|
lpdw = &pvs->DistRing[i].dwMediaType;
|
|
|
|
iSel = ComboBox_GetCurSel(hwndCtl);
|
|
ASSERT(LB_ERR != iSel);
|
|
|
|
*lpdw = ComboBox_GetItemData(hwndCtl, iSel);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_NOTIFY handler
|
|
Returns: varies
|
|
Cond: --
|
|
*/
|
|
LRESULT PRIVATE CheapRing_OnNotify(
|
|
PRING this,
|
|
int idFrom,
|
|
NMHDR FAR * lpnmhdr)
|
|
{
|
|
LRESULT lRet = 0;
|
|
|
|
switch (lpnmhdr->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
break;
|
|
|
|
case PSN_KILLACTIVE:
|
|
// N.b. This message is not sent if user clicks Cancel!
|
|
// N.b. This message is sent prior to PSN_APPLY
|
|
//
|
|
break;
|
|
|
|
case PSN_APPLY:
|
|
lRet = CheapRing_OnApply(this) ? PSNRET_NOERROR : PSNRET_INVALID;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return lRet;
|
|
}
|
|
|
|
|
|
static BOOL s_bCheapRingRecurse = FALSE;
|
|
|
|
LRESULT INLINE CheapRing_DefProc(
|
|
HWND hDlg,
|
|
UINT msg,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
ENTER_X()
|
|
{
|
|
s_bCheapRingRecurse = TRUE;
|
|
}
|
|
LEAVE_X()
|
|
|
|
return DefDlgProc(hDlg, msg, wParam, lParam);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Real dialog proc
|
|
Returns: varies
|
|
Cond: --
|
|
*/
|
|
LRESULT CheapRing_DlgProc(
|
|
PRING this,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
#ifdef CS_HELP
|
|
// UE used the control IDs as help IDs. To prevent mix-ups in
|
|
// the future (ie, when the control IDs change), here are the
|
|
// help IDs.
|
|
#define IDH_UNI_RING_LBL_RING1 1088
|
|
#define IDH_UNI_RING_TYPE_RING1 1091
|
|
#define IDH_UNI_RING_LBL_RING2 1089
|
|
#define IDH_UNI_RING_TYPE_RING2 1092
|
|
#define IDH_UNI_RING_LBL_RING3 1090
|
|
#define IDH_UNI_RING_TYPE_RING3 1093
|
|
#pragma data_seg(DATASEG_READONLY)
|
|
const static DWORD rgHelpIDs[] = {
|
|
IDC_RING_CHECK, IDH_UNI_RING_SERVICES,
|
|
IDC_LBL_RING1, IDH_UNI_RING_LBL_RING1,
|
|
IDC_TYPE_RING1, IDH_UNI_RING_TYPE_RING1,
|
|
IDC_LBL_RING2, IDH_UNI_RING_LBL_RING2,
|
|
IDC_TYPE_RING2, IDH_UNI_RING_TYPE_RING2,
|
|
IDC_LBL_RING3, IDH_UNI_RING_LBL_RING3,
|
|
IDC_TYPE_RING3, IDH_UNI_RING_TYPE_RING3,
|
|
0, 0 };
|
|
#pragma data_seg()
|
|
#endif
|
|
|
|
switch (message)
|
|
{
|
|
HANDLE_MSG(this, WM_INITDIALOG, CheapRing_OnInitDialog);
|
|
HANDLE_MSG(this, WM_COMMAND, CheapRing_OnCommand);
|
|
HANDLE_MSG(this, WM_NOTIFY, CheapRing_OnNotify);
|
|
|
|
|
|
#ifdef CS_HELP
|
|
case WM_HELP:
|
|
WinHelp(((LPHELPINFO)lParam)->hItemHandle, c_szUnimdmHelpFile, HELP_WM_HELP, (DWORD)(LPVOID)rgHelpIDs);
|
|
return 0;
|
|
|
|
case WM_CONTEXTMENU:
|
|
WinHelp((HWND)wParam, c_szUnimdmHelpFile, HELP_CONTEXTMENU, (DWORD)(LPVOID)rgHelpIDs);
|
|
return 0;
|
|
#endif
|
|
|
|
default:
|
|
return CheapRing_DefProc(this->hdlg, message, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Dialog Wrapper
|
|
Returns: varies
|
|
Cond: --
|
|
*/
|
|
BOOL CALLBACK CheapRing_WrapperProc(
|
|
HWND hDlg, // std params
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
PRING this;
|
|
|
|
// Cool windowsx.h dialog technique. For full explanation, see
|
|
// WINDOWSX.TXT. This supports multiple-instancing of dialogs.
|
|
//
|
|
ENTER_X()
|
|
{
|
|
if (s_bCheapRingRecurse)
|
|
{
|
|
s_bCheapRingRecurse = FALSE;
|
|
LEAVE_X()
|
|
return FALSE;
|
|
}
|
|
}
|
|
LEAVE_X()
|
|
|
|
this = CheapRing_GetPtr(hDlg);
|
|
if (this == NULL)
|
|
{
|
|
// (WM_SETFONT is the first message received by dialogs)
|
|
if (WM_SETFONT == message)
|
|
{
|
|
this = (PRING)LocalAlloc(LPTR, sizeof(RING));
|
|
if (!this)
|
|
{
|
|
MsgBox(g_hinst,
|
|
hDlg,
|
|
MAKEINTRESOURCE(IDS_OOM_SETTINGS),
|
|
MAKEINTRESOURCE(IDS_CAP_RING),
|
|
NULL,
|
|
MB_ERROR);
|
|
EndDialog(hDlg, IDCANCEL);
|
|
return (BOOL)CheapRing_DefProc(hDlg, message, wParam, lParam);
|
|
}
|
|
this->hdlg = hDlg;
|
|
CheapRing_SetPtr(hDlg, this);
|
|
}
|
|
else
|
|
{
|
|
return (BOOL)CheapRing_DefProc(hDlg, message, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
if (message == WM_DESTROY)
|
|
{
|
|
CheapRing_DlgProc(this, message, wParam, lParam);
|
|
LocalFree((HLOCAL)OFFSETOF(this));
|
|
CheapRing_SetPtr(hDlg, NULL);
|
|
return 0;
|
|
}
|
|
|
|
return SetDlgMsgResult(hDlg, message, CheapRing_DlgProc(this, message, wParam, lParam));
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// DTMF edit box proc
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Handle WM_CHAR
|
|
|
|
Returns: TRUE to let the characters by
|
|
FALSE to prohibit
|
|
Cond: --
|
|
*/
|
|
BOOL PRIVATE DTMFEditProc_OnChar(
|
|
HWND hwnd,
|
|
UINT ch,
|
|
int cRepeat)
|
|
{
|
|
BOOL bRet;
|
|
|
|
// Is this a numerical digit,
|
|
// a backspace,
|
|
// or a valid DTMF digit?
|
|
if (IsCharAlphaNumeric((TCHAR)ch) && !IsCharAlpha((TCHAR)ch) ||
|
|
VK_BACK == LOBYTE(VkKeyScan((TCHAR)ch)) ||
|
|
'A' == ch || 'B' == ch || 'C' == ch || 'D' == ch ||
|
|
'*' == ch || '#' == ch)
|
|
{
|
|
// Yes
|
|
bRet = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// No
|
|
MessageBeep(MB_OK);
|
|
bRet = FALSE;
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Number proc. Only allow numbers to be entered into this edit box.
|
|
|
|
Returns: varies
|
|
Cond: --
|
|
*/
|
|
LRESULT CALLBACK DTMFEditProc(
|
|
HWND hwnd, // std params
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
WNDPROC pfn = (WNDPROC)GetWindowLong(hwnd, GWL_USERDATA);
|
|
|
|
// BUGBUG: doesn't handle paste correctly!
|
|
|
|
switch (message)
|
|
{
|
|
case WM_CHAR:
|
|
if (!DTMFEditProc_OnChar(hwnd, (UINT)wParam, LOWORD(lParam)))
|
|
return 1; // Don't process this character
|
|
break;
|
|
}
|
|
|
|
return CallWindowProc(pfn, hwnd, message, wParam, lParam);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------------
|
|
// Call forwarding dialog code
|
|
//-----------------------------------------------------------------------------------
|
|
|
|
|
|
typedef struct tagCALLFWD
|
|
{
|
|
HWND hdlg; // dialog handle
|
|
LPMODEMINFO pmi; // modeminfo struct passed into dialog
|
|
|
|
} CALLFWD, FAR * PCALLFWD;
|
|
|
|
|
|
#define CallFwd_GetPtr(hwnd) (PCALLFWD)GetWindowLong(hwnd, DWL_USER)
|
|
#define CallFwd_SetPtr(hwnd, lp) (PCALLFWD)SetWindowLong(hwnd, DWL_USER, (LONG)(lp))
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Enable/disable all the controls
|
|
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
void PRIVATE CallFwd_EnableControls(
|
|
PCALLFWD this,
|
|
BOOL bEnable)
|
|
{
|
|
HWND hwnd = this->hdlg;
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_FWD_ACT), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACT), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_FWD_DEACT), bEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_DEACT), bEnable);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_INITDIALOG Handler
|
|
Returns: FALSE when we assign the control focus
|
|
Cond: --
|
|
*/
|
|
BOOL PRIVATE CallFwd_OnInitDialog(
|
|
PCALLFWD this,
|
|
HWND hwndFocus,
|
|
LPARAM lParam) // expected to be PROPSHEETINFO
|
|
{
|
|
LPPROPSHEETPAGE lppsp = (LPPROPSHEETPAGE)lParam;
|
|
HWND hwnd = this->hdlg;
|
|
HWND hwndCtl;
|
|
BOOL bEnable;
|
|
PVOICEFEATURES pvs;
|
|
WNDPROC pfn;
|
|
|
|
ASSERT((LPTSTR)lppsp->lParam);
|
|
|
|
this->pmi = (LPMODEMINFO)lppsp->lParam;
|
|
pvs = &this->pmi->pglobal->vs;
|
|
|
|
// Subclass the edit boxes that only accept DTMF digits
|
|
hwndCtl = GetDlgItem(hwnd, IDC_ACT);
|
|
pfn = SubclassWindow(hwndCtl, DTMFEditProc);
|
|
SetWindowLong(hwndCtl, GWL_USERDATA, (LONG)pfn);
|
|
|
|
hwndCtl = GetDlgItem(hwnd, IDC_DEACT);
|
|
pfn = SubclassWindow(hwndCtl, DTMFEditProc);
|
|
SetWindowLong(hwndCtl, GWL_USERDATA, (LONG)pfn);
|
|
|
|
// Enable/disable controls
|
|
|
|
bEnable = IsFlagSet(pvs->dwFlags, VSF_CALL_FWD);
|
|
|
|
Button_SetCheck(GetDlgItem(hwnd, IDC_FWD_CHECK), bEnable);
|
|
CallFwd_EnableControls(this, bEnable);
|
|
|
|
// Initialize controls
|
|
|
|
hwndCtl = GetDlgItem(hwnd, IDC_ACT);
|
|
Edit_SetText(hwndCtl, pvs->szActivationCode);
|
|
Edit_LimitText(hwndCtl, SIZECHARS(pvs->szActivationCode)-1);
|
|
|
|
hwndCtl = GetDlgItem(hwnd, IDC_DEACT);
|
|
Edit_SetText(hwndCtl, pvs->szDeactivationCode);
|
|
Edit_LimitText(hwndCtl, SIZECHARS(pvs->szDeactivationCode)-1);
|
|
|
|
return TRUE; // default initial focus
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_COMMAND Handler
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
void PRIVATE CallFwd_OnCommand(
|
|
PCALLFWD this,
|
|
int id,
|
|
HWND hwndCtl,
|
|
UINT uNotifyCode)
|
|
{
|
|
BOOL bCheck;
|
|
|
|
switch (id)
|
|
{
|
|
case IDC_FWD_CHECK:
|
|
bCheck = Button_GetCheck(hwndCtl);
|
|
CallFwd_EnableControls(this, bCheck);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Validate the user's settings.
|
|
|
|
The call forwarding fields must be filled in if the
|
|
service is turned on.
|
|
|
|
Returns: TRUE if valid
|
|
|
|
Cond: --
|
|
*/
|
|
BOOL PRIVATE CallFwd_ValidateSettings(
|
|
PCALLFWD this)
|
|
{
|
|
HWND hwnd = this->hdlg;
|
|
HWND hwndCtl;
|
|
|
|
// Is the service turned on?
|
|
if (Button_GetCheck(GetDlgItem(hwnd, IDC_FWD_CHECK)))
|
|
{
|
|
// Yes; are the fields filled in?
|
|
hwndCtl = GetDlgItem(hwnd, IDC_ACT);
|
|
if (0 == Edit_GetTextLength(hwndCtl))
|
|
{
|
|
// No; this is naughty
|
|
MsgBox(g_hinst,
|
|
hwnd,
|
|
MAKEINTRESOURCE(IDS_ERR_NEED_VALUE),
|
|
MAKEINTRESOURCE(IDS_CAP_CALLFWD),
|
|
NULL,
|
|
MB_ERROR);
|
|
|
|
// Set the focus on the offending control
|
|
PostMessage(hwnd, WM_NEXTDLGCTL, (WPARAM)hwndCtl, (LPARAM)TRUE);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
hwndCtl = GetDlgItem(hwnd, IDC_DEACT);
|
|
if (0 == Edit_GetTextLength(hwndCtl))
|
|
{
|
|
// No; this is naughty
|
|
MsgBox(g_hinst,
|
|
hwnd,
|
|
MAKEINTRESOURCE(IDS_ERR_NEED_VALUE),
|
|
MAKEINTRESOURCE(IDS_CAP_CALLFWD),
|
|
NULL,
|
|
MB_ERROR);
|
|
|
|
// Set the focus on the offending control
|
|
PostMessage(hwnd, WM_NEXTDLGCTL, (WPARAM)hwndCtl, (LPARAM)TRUE);
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: PSN_APPLY handler
|
|
Returns: --
|
|
Cond: --
|
|
*/
|
|
BOOL PRIVATE CallFwd_OnApply(
|
|
PCALLFWD this)
|
|
{
|
|
BOOL bRet;
|
|
HWND hwnd = this->hdlg;
|
|
HWND hwndCtl;
|
|
PVOICEFEATURES pvs = &this->pmi->pglobal->vs;
|
|
|
|
bRet = CallFwd_ValidateSettings(this);
|
|
|
|
if (bRet)
|
|
{
|
|
if (Button_GetCheck(GetDlgItem(hwnd, IDC_FWD_CHECK)))
|
|
{
|
|
SetFlag(pvs->dwFlags, VSF_CALL_FWD);
|
|
}
|
|
else
|
|
{
|
|
ClearFlag(pvs->dwFlags, VSF_CALL_FWD);
|
|
}
|
|
|
|
hwndCtl = GetDlgItem(hwnd, IDC_ACT);
|
|
Edit_GetText(hwndCtl, pvs->szActivationCode, SIZECHARS(pvs->szActivationCode));
|
|
|
|
hwndCtl = GetDlgItem(hwnd, IDC_DEACT);
|
|
Edit_GetText(hwndCtl, pvs->szDeactivationCode, SIZECHARS(pvs->szDeactivationCode));
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: WM_NOTIFY handler
|
|
Returns: varies
|
|
Cond: --
|
|
*/
|
|
LRESULT PRIVATE CallFwd_OnNotify(
|
|
PCALLFWD this,
|
|
int idFrom,
|
|
NMHDR FAR * lpnmhdr)
|
|
{
|
|
LRESULT lRet = 0;
|
|
|
|
switch (lpnmhdr->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
break;
|
|
|
|
case PSN_KILLACTIVE:
|
|
// N.b. This message is not sent if user clicks Cancel!
|
|
// N.b. This message is sent prior to PSN_APPLY
|
|
//
|
|
break;
|
|
|
|
case PSN_APPLY:
|
|
lRet = CallFwd_OnApply(this) ? PSNRET_NOERROR : PSNRET_INVALID;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return lRet;
|
|
}
|
|
|
|
|
|
static BOOL s_bCallFwdRecurse = FALSE;
|
|
|
|
LRESULT INLINE CallFwd_DefProc(
|
|
HWND hDlg,
|
|
UINT msg,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
ENTER_X()
|
|
{
|
|
s_bCallFwdRecurse = TRUE;
|
|
}
|
|
LEAVE_X()
|
|
|
|
return DefDlgProc(hDlg, msg, wParam, lParam);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Real dialog proc
|
|
Returns: varies
|
|
Cond: --
|
|
*/
|
|
LRESULT CallFwd_DlgProc(
|
|
PCALLFWD this,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
#ifdef CS_HELP
|
|
// UE used the control IDs as help IDs. To prevent mix-ups in
|
|
// the future (ie, when the control IDs change), here are the
|
|
// help IDs.
|
|
#define IDH_UNI_CALLFWD_SERVICES 1062
|
|
#define IDH_UNI_CALLFWD_FWD_ACT 1063
|
|
#define IDH_UNI_CALLFWD_ACT 1068
|
|
#define IDH_UNI_CALLFWD_FWD_DEACT 1064
|
|
#define IDH_UNI_CALLFWD_DEACT 1067
|
|
#pragma data_seg(DATASEG_READONLY)
|
|
const static DWORD rgHelpIDs[] = {
|
|
IDC_FWD_CHECK, IDH_UNI_CALLFWD_SERVICES,
|
|
IDC_FWD_ACT, IDH_UNI_CALLFWD_FWD_ACT,
|
|
IDC_ACT, IDH_UNI_CALLFWD_ACT,
|
|
IDC_FWD_DEACT, IDH_UNI_CALLFWD_FWD_DEACT,
|
|
IDC_DEACT, IDH_UNI_CALLFWD_DEACT,
|
|
0, 0 };
|
|
#pragma data_seg()
|
|
#endif
|
|
|
|
switch (message)
|
|
{
|
|
HANDLE_MSG(this, WM_INITDIALOG, CallFwd_OnInitDialog);
|
|
HANDLE_MSG(this, WM_COMMAND, CallFwd_OnCommand);
|
|
HANDLE_MSG(this, WM_NOTIFY, CallFwd_OnNotify);
|
|
|
|
#ifdef CS_HELP
|
|
case WM_HELP:
|
|
WinHelp(((LPHELPINFO)lParam)->hItemHandle, c_szUnimdmHelpFile, HELP_WM_HELP, (DWORD)(LPVOID)rgHelpIDs);
|
|
return 0;
|
|
|
|
case WM_CONTEXTMENU:
|
|
WinHelp((HWND)wParam, c_szUnimdmHelpFile, HELP_CONTEXTMENU, (DWORD)(LPVOID)rgHelpIDs);
|
|
return 0;
|
|
#endif
|
|
|
|
default:
|
|
return CallFwd_DefProc(this->hdlg, message, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Dialog Wrapper
|
|
Returns: varies
|
|
Cond: --
|
|
*/
|
|
BOOL CALLBACK CallFwd_WrapperProc(
|
|
HWND hDlg, // std params
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
PCALLFWD this;
|
|
|
|
// Cool windowsx.h dialog technique. For full explanation, see
|
|
// WINDOWSX.TXT. This supports multiple-instancing of dialogs.
|
|
//
|
|
ENTER_X()
|
|
{
|
|
if (s_bCallFwdRecurse)
|
|
{
|
|
s_bCallFwdRecurse = FALSE;
|
|
LEAVE_X()
|
|
return FALSE;
|
|
}
|
|
}
|
|
LEAVE_X()
|
|
|
|
this = CallFwd_GetPtr(hDlg);
|
|
if (this == NULL)
|
|
{
|
|
if (message == WM_INITDIALOG)
|
|
{
|
|
this = (PCALLFWD)LocalAlloc(LPTR, sizeof(CALLFWD));
|
|
if (!this)
|
|
{
|
|
MsgBox(g_hinst,
|
|
hDlg,
|
|
MAKEINTRESOURCE(IDS_OOM_SETTINGS),
|
|
MAKEINTRESOURCE(IDS_CAP_RING),
|
|
NULL,
|
|
MB_ERROR);
|
|
EndDialog(hDlg, IDCANCEL);
|
|
return (BOOL)CallFwd_DefProc(hDlg, message, wParam, lParam);
|
|
}
|
|
this->hdlg = hDlg;
|
|
CallFwd_SetPtr(hDlg, this);
|
|
}
|
|
else
|
|
{
|
|
return (BOOL)CallFwd_DefProc(hDlg, message, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
if (message == WM_DESTROY)
|
|
{
|
|
CallFwd_DlgProc(this, message, wParam, lParam);
|
|
LocalFree((HLOCAL)OFFSETOF(this));
|
|
CallFwd_SetPtr(hDlg, NULL);
|
|
return 0;
|
|
}
|
|
|
|
return SetDlgMsgResult(hDlg, message, CallFwd_DlgProc(this, message, wParam, lParam));
|
|
}
|
|
|
|
|
|
|