path: root/private/unimodem/modemui/ring.c

//---------------------------------------------------------------------------
//
// 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));
    }