//---------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation 1998
//
// File: cplisdn.c
//
// This files contains the dialog code for the ISDN page
// of the modem properties.
//
// History:
//  1/23/1998 JosephJ Created
//
//---------------------------------------------------------------------------


/////////////////////////////////////////////////////  INCLUDES

#include "proj.h"         // common headers
#include "cplui.h"         // common headers

#define USPROP  fISDN_SWITCHPROP_US
#define MSNPROP fISDN_SWITCHPROP_MSN
#define EAZPROP fISDN_SWITCHPROP_EAZ
#define ONECH   fISDN_SWITCHPROP_1CH

/////////////////////////////////////////////////////  CONTROLLING DEFINES

/////////////////////////////////////////////////////  TYPEDEFS

#define SIG_CPLISDN 0xf6b2ea13

typedef struct
{
    DWORD dwSig;            // Must be set to SIG_CPLISDN
    HWND  hdlg;             // dialog handle
    HWND  hwndCB_ST;        // switch type
    HWND  hwndEB_Number1;   // 1st Number
    HWND  hwndEB_ID1;       // 1st ID
    HWND  hwndEB_Number2;   // 2nd Number
    HWND  hwndEB_ID2;       // 2nd ID

    LPMODEMINFO pmi;        // modeminfo struct passed into dialog

} CPLISDN, FAR * PCPLISDN;

#define VALID_CPLISDN(_pcplgen)  ((_pcplgen)->dwSig == SIG_CPLISDN)

ISDN_STATIC_CONFIG *
ConstructISDNStaticConfigFromDlg(
                        PCPLISDN this
                        );

// This is the structure that is used to fill the stopbits listbox
static LBMAP s_rgISDNSwitchType[] =
{
    { dwISDN_SWITCH_ATT1, IDS_ISDN_SWITCH_ATT1    },
    { dwISDN_SWITCH_ATT_PTMP, IDS_ISDN_SWITCH_ATT_PTMP    },
    { dwISDN_SWITCH_NI1, IDS_ISDN_SWITCH_NI1      },
    { dwISDN_SWITCH_DMS100, IDS_ISDN_SWITCH_DMS100},
    { dwISDN_SWITCH_INS64, IDS_ISDN_SWITCH_INS64  },
    { dwISDN_SWITCH_DSS1, IDS_ISDN_SWITCH_DSS1    },
    { dwISDN_SWITCH_1TR6, IDS_ISDN_SWITCH_1TR6    },
    { dwISDN_SWITCH_VN3, IDS_ISDN_SWITCH_VN3      },
    { dwISDN_SWITCH_BELGIUM1, IDS_ISDN_SWITCH_BELGIUM1},
    { dwISDN_SWITCH_AUS1, IDS_ISDN_SWITCH_AUS1    },
    { dwISDN_SWITCH_UNKNOWN, IDS_ISDN_SWITCH_UNKNOWN    },

    { 0,   0   }
};

DWORD SelectISDNSwitchType(
            DWORD dwValue,
            void *pvContext
            );

UINT GetNumEntries(
      IN  DWORD dwSwitchProps,
      IN  ISDN_STATIC_CAPS *pCaps,
      OUT BOOL *pfSetID
      );

void InitSpidEaz (PCPLISDN this);


PCPLISDN CplISDN_GetPtr(HWND hwnd)
{
    PCPLISDN pCplISDN = (PCPLISDN) GetWindowLongPtr(hwnd, DWLP_USER);
    if (!pCplISDN || VALID_CPLISDN(pCplISDN))
    {
        return pCplISDN;
    }
    else
    {
        MYASSERT(FALSE);
        return NULL;
    }
}

void CplISDN_SetPtr(HWND hwnd, PCPLISDN pCplISDN)
{
    if (pCplISDN && !VALID_CPLISDN(pCplISDN))
    {
        MYASSERT(FALSE);
        pCplISDN = NULL;
    }
   
    SetWindowLongPtr(hwnd, DWLP_USER, (ULONG_PTR) pCplISDN);
}


LRESULT PRIVATE CplISDN_OnNotify(
    PCPLISDN this,
    int idFrom,
    NMHDR FAR * lpnmhdr);

void PRIVATE CplISDN_OnSetActive(
    PCPLISDN this);

void PRIVATE CplISDN_OnKillActive(
    PCPLISDN this);
    



//------------------------------------------------------------------------------
//  Advanced Settings dialog code
//------------------------------------------------------------------------------


/*----------------------------------------------------------
Purpose: WM_INITDIALOG Handler
Returns: FALSE when we assign the control focus
Cond:    --
*/
BOOL PRIVATE CplISDN_OnInitDialog(
    PCPLISDN this,
    HWND hwndFocus,
    LPARAM lParam)              // expected to be PROPSHEETINFO 
{

    HWND hwnd = this->hdlg;
    LPPROPSHEETPAGE lppsp = (LPPROPSHEETPAGE)lParam;
    ISDN_STATIC_CONFIG *pConfig = NULL;

    ASSERT((LPTSTR)lppsp->lParam);
    this->pmi = (LPMODEMINFO)lppsp->lParam;
    pConfig = this->pmi->pglobal->pIsdnStaticConfig;
        
    this->hwndCB_ST     = GetDlgItem(hwnd, IDC_CB_ISDN_ST);
    this->hwndEB_Number1 = GetDlgItem(hwnd, IDC_EB_ISDN_N1);
    this->hwndEB_ID1     = GetDlgItem(hwnd, IDC_EB_ISDN_ID1);
    this->hwndEB_Number2 = GetDlgItem(hwnd, IDC_EB_ISDN_N2);
    this->hwndEB_ID2     = GetDlgItem(hwnd, IDC_EB_ISDN_ID2);

    if (pConfig->dwNumEntries)
    {
        BOOL fSetID=FALSE;
        char *sz=NULL;

        Edit_LimitText(this->hwndEB_Number1, LINE_LEN-1);
        Edit_LimitText(this->hwndEB_ID1, LINE_LEN-1);
        Edit_LimitText(this->hwndEB_Number2, LINE_LEN-1);
        Edit_LimitText(this->hwndEB_ID2, LINE_LEN-1);
    
        if (pConfig->dwSwitchProperties & (USPROP|EAZPROP))
        {
            fSetID=TRUE;
        }

        if (pConfig->dwNumberListOffset)
        {
            // get the 1st number
            sz =  ISDN_NUMBERS_FROM_CONFIG(pConfig);
            //Edit_SetTextA(this->hwndEB_Number1, sz);
            SetWindowTextA(this->hwndEB_Number1, sz);

            if (pConfig->dwNumEntries>1)
            {
                // get the 2nd number
                sz += lstrlenA(sz)+1;
                // Edit_SetTextA(this->hwndEB_Number2, sz);
                SetWindowTextA(this->hwndEB_Number2, sz);
            }
            else
            {
                EnableWindow(this->hwndEB_Number2, FALSE);
            }
        }

        if (fSetID)
        {
            if (pConfig->dwIDListOffset)
            {
                // get the 1st number
                sz =  ISDN_IDS_FROM_CONFIG(pConfig);
                //Edit_SetTextA(this->hwndEB_ID1, sz);
                SetWindowTextA(this->hwndEB_ID1, sz);
    
                if (pConfig->dwNumEntries>1)
                {
                    // get the 2nd number
                    sz += lstrlenA(sz)+1;
                    //Edit_SetTextA(this->hwndEB_ID2, sz);
                    SetWindowTextA(this->hwndEB_ID2, sz);
                }
                else
                {
                    EnableWindow(this->hwndEB_ID2, FALSE);
                }
            }
        }
        else
        {
            EnableWindow(this->hwndEB_ID1, FALSE);
            EnableWindow(this->hwndEB_ID2, FALSE);
        }

        // Edit_SetText(this->hwndEB_Number, TEXT("425-703-9280"));
        // Edit_SetText(this->hwndEB_ID, TEXT("Joseph M. Joy"));
    }

    // Fill switch type list box...
    LBMapFill(
            this->hwndCB_ST,
            s_rgISDNSwitchType,
            SelectISDNSwitchType,
            this
            );

    InitSpidEaz (this);

    return TRUE;   // let USER set the initial focus
}


/*----------------------------------------------------------
Purpose: PSN_APPLY handler
Returns: --
Cond:    --
*/
void PRIVATE CplISDN_OnApply(
    PCPLISDN this)
{
    BOOL fConfigChanged = FALSE;
    ISDN_STATIC_CONFIG * pConfig =  ConstructISDNStaticConfigFromDlg(this);

    if (pConfig)
    {
        ISDN_STATIC_CONFIG * pOldConfig = this->pmi->pglobal->pIsdnStaticConfig;
        if (pOldConfig)
        {
            if (   (pOldConfig->dwTotalSize != pConfig->dwTotalSize)
                || memcmp(pOldConfig, pConfig, pConfig->dwTotalSize))
            {
                // ISDN config has changed...
                fConfigChanged = TRUE;
            }

            // do a final validation of the configuration...

            FREE_MEMORY(pOldConfig);
            pOldConfig=NULL;
        }
        else
        {
            // hmm... old config didn't exist ?!
            fConfigChanged = TRUE;
        }

        if (fConfigChanged)
        {
            SetFlag(this->pmi->uFlags,  MIF_ISDN_CONFIG_CHANGED);
        }

        this->pmi->pglobal->pIsdnStaticConfig = pConfig;
    }

    this->pmi->idRet = IDOK;
}


/*----------------------------------------------------------
Purpose: WM_COMMAND Handler
Returns: --
Cond:    --
*/
void PRIVATE CplISDN_OnCommand(
    PCPLISDN this,
    int id,
    HWND hwndCtl,
    UINT uNotifyCode)
{
    switch (id)
    {
        case IDOK:
            CplISDN_OnApply(this);
            // Fall thru
            //   |   |
            //   v   v
        case IDCANCEL:
            EndDialog(this->hdlg, id);
            break;

        case  IDC_CB_ISDN_ST:

            if (uNotifyCode == CBN_SELENDOK)
            {
                InitSpidEaz (this);
            }
            break;

        default:
            break;
    }
}


/*----------------------------------------------------------
Purpose: WM_DESTROY handler
Returns: --
Cond:    --
*/
void PRIVATE CplISDN_OnDestroy(
    PCPLISDN this)
{
}


/////////////////////////////////////////////////////  EXPORTED FUNCTIONS

static BOOL s_bCplISDNRecurse = FALSE;

LRESULT INLINE CplISDN_DefProc(
    HWND hDlg, 
    UINT msg,
    WPARAM wParam,
    LPARAM lParam) 
{
    ENTER_X()
        {
        s_bCplISDNRecurse = TRUE;
        }
    LEAVE_X()

    return DefDlgProc(hDlg, msg, wParam, lParam); 
}


/*----------------------------------------------------------
Purpose: Real dialog proc
Returns: varies
Cond:    --
*/
LRESULT CplISDN_DlgProc(
    PCPLISDN this,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    switch (message)
        {
        HANDLE_MSG(this, WM_INITDIALOG, CplISDN_OnInitDialog);
        HANDLE_MSG(this, WM_COMMAND, CplISDN_OnCommand);
        HANDLE_MSG(this, WM_NOTIFY,  CplISDN_OnNotify);
        HANDLE_MSG(this, WM_DESTROY, CplISDN_OnDestroy);

    case WM_HELP:
        WinHelp(((LPHELPINFO)lParam)->hItemHandle, c_szWinHelpFile, HELP_WM_HELP, (ULONG_PTR)(LPVOID)g_aHelpIDs_IDD_CPL_ISDN);
        return 0;

    case WM_CONTEXTMENU:
        WinHelp((HWND)wParam, c_szWinHelpFile, HELP_CONTEXTMENU, (ULONG_PTR)(LPVOID)g_aHelpIDs_IDD_CPL_ISDN);
        return 0;

    default:
        return CplISDN_DefProc(this->hdlg, message, wParam, lParam);
        }
}


/*----------------------------------------------------------
Purpose: Dialog Wrapper
Returns: varies
Cond:    --
*/
INT_PTR CALLBACK CplISDN_WrapperProc(
    HWND hDlg,          // std params
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    PCPLISDN this;

    // Cool windowsx.h dialog technique.  For full explanation, see
    //  WINDOWSX.TXT.  This supports multiple-instancing of dialogs.
    //
    ENTER_X()
    {
        if (s_bCplISDNRecurse)
        {
            s_bCplISDNRecurse = FALSE;
            LEAVE_X()
            return FALSE;
        }
    }
    LEAVE_X()

    this = CplISDN_GetPtr(hDlg);
    if (this == NULL)
    {
        if (message == WM_INITDIALOG)
        {
            this = (PCPLISDN)ALLOCATE_MEMORY( sizeof(CPLISDN));
            if (!this)
            {
                MsgBox(g_hinst,
                       hDlg, 
                       MAKEINTRESOURCE(IDS_OOM_SETTINGS), 
                       MAKEINTRESOURCE(IDS_CAP_SETTINGS),
                       NULL,
                       MB_ERROR);
                EndDialog(hDlg, IDCANCEL);
                return (BOOL)CplISDN_DefProc(hDlg, message, wParam, lParam);
            }
            this->dwSig = SIG_CPLISDN;
            this->hdlg = hDlg;
            CplISDN_SetPtr(hDlg, this);
        }
        else
        {
            return (BOOL)CplISDN_DefProc(hDlg, message, wParam, lParam);
        }
    }

    if (message == WM_DESTROY)
    {
        CplISDN_DlgProc(this, message, wParam, lParam);
        FREE_MEMORY((HLOCAL)OFFSETOF(this));
        CplISDN_SetPtr(hDlg, NULL);
        return 0;
    }

    return SetDlgMsgResult(
                hDlg,
                message,
                CplISDN_DlgProc(this, message, wParam, lParam)
                );
}


LRESULT PRIVATE CplISDN_OnNotify(
    PCPLISDN this,
    int idFrom,
    NMHDR FAR * lpnmhdr)
{
    LRESULT lRet = 0;
    
    switch (lpnmhdr->code)
    {
    case PSN_SETACTIVE:
        CplISDN_OnSetActive(this);
        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
        CplISDN_OnKillActive(this);
        break;

    case PSN_APPLY:
        CplISDN_OnApply(this);
        break;

    default:
        break;
    }

    return lRet;
}

void PRIVATE CplISDN_OnSetActive(
    PCPLISDN this)
{
    // Init any display ....
}


/*----------------------------------------------------------
Purpose: PSN_KILLACTIVE handler
Returns: --
Cond:    --
*/
void PRIVATE CplISDN_OnKillActive(
    PCPLISDN this)
{

    // CplISDN_OnApply(this);
    // Save the settings back to the modem info struct so the Connection
    // page can invoke the Port Settings property dialog with the 
    // correct settings.

}


DWORD SelectISDNSwitchType(
            DWORD dwValue,
            void *pvContext
            )
{
    PCPLISDN this = (PCPLISDN) pvContext;
    DWORD dwRet = 0;
    BOOL fSelected = FALSE;
    BOOL fAvailable = FALSE;
    ISDN_STATIC_CAPS *pCaps = this->pmi->pglobal->pIsdnStaticCaps;
    ISDN_STATIC_CONFIG *pConfig = this->pmi->pglobal->pIsdnStaticConfig;
    UINT u =  pCaps->dwNumSwitchTypes;
    DWORD *pdwType =  (DWORD*)(((BYTE*)pCaps)+pCaps->dwSwitchTypeOffset);
    DWORD dwSelectedType =  pConfig->dwSwitchType;

    // check to see if this switch type is available...
    while(u--)
    {
        if (*pdwType++==dwValue)
        {
            fAvailable = TRUE;
            if (dwSelectedType == dwValue)
            {
                fSelected=TRUE;
            }
            break;
        }
    }
    

    if (fAvailable)
    {
        dwRet = fLBMAP_ADD_TO_LB;
        if (fSelected)
        {
            dwRet |= fLBMAP_SELECT;
        }
    }

    return dwRet;
}


ISDN_STATIC_CONFIG *
ConstructISDNStaticConfigFromDlg(
                        PCPLISDN this
                        )
{
    DWORD dwSwitchType=0;
    DWORD dwSwitchProps=0;
    DWORD dwNumEntries=0;
    BOOL fSetID=FALSE;
    DWORD dwTotalSize = 0;
    char Number1[LINE_LEN];
    char Number2[LINE_LEN];
    char ID1[LINE_LEN];
    char ID2[LINE_LEN];
    UINT cbNumber1=0;
    UINT cbNumber2=0;
    UINT cbID1=0;
    UINT cbID2=0;

    ISDN_STATIC_CAPS *pCaps = this->pmi->pglobal->pIsdnStaticCaps;
    ISDN_STATIC_CONFIG *pConfig = NULL;

    if (!pCaps) goto end;

    dwSwitchType = (DWORD)ComboBox_GetItemData(
                            this->hwndCB_ST,
                            ComboBox_GetCurSel(this->hwndCB_ST)
                            );

    dwSwitchProps =  GetISDNSwitchTypeProps(dwSwitchType);

    dwNumEntries= GetNumEntries(
                          dwSwitchProps,
                          pCaps,
                          &fSetID
                          );


    #define szDUMMY "123"

    cbNumber1 = 1+GetWindowTextA(this->hwndEB_Number1, Number1,sizeof(Number1));
    cbID1     = 1+GetWindowTextA(this->hwndEB_ID1, ID1, sizeof(ID1));

    if (dwNumEntries==2)
    {
        cbNumber2 = 1+GetWindowTextA(
                            this->hwndEB_Number2,
                            Number2,
                            sizeof(Number2)
                            );
        cbID2     = 1+GetWindowTextA(this->hwndEB_ID2, ID2, sizeof(ID2));
    }

    // Compute total size
    dwTotalSize = sizeof(*pConfig);
    dwTotalSize += 1+cbNumber1+cbNumber2; // for numbers.
    if (fSetID)
    {
        dwTotalSize += 1+cbID1+cbID2; // for IDs.
    }


    // Round up to multiple of DWORDs
    dwTotalSize += 3;
    dwTotalSize &= ~3;

    pConfig = ALLOCATE_MEMORY( dwTotalSize);

    if (pConfig == NULL) {

        goto end;
    }

    pConfig->dwSig       = dwSIG_ISDN_STATIC_CONFIGURATION;
    pConfig->dwTotalSize = dwTotalSize;
    pConfig->dwSwitchType = dwSwitchType;
    pConfig->dwSwitchProperties = dwSwitchProps;

    pConfig->dwNumEntries = dwNumEntries;
    pConfig->dwNumberListOffset = sizeof(*pConfig);

    // add the numbers
    if (cbNumber1 > 1)
    {
        BYTE *pb =  ISDN_NUMBERS_FROM_CONFIG(pConfig);
        CopyMemory(pb,Number1, cbNumber1);

        if (dwNumEntries>1)
        {
            pb+=cbNumber1;
            CopyMemory(pb,Number2, cbNumber2);
        }
    }

    // add the IDs, if required
    //
    if (fSetID)
    {
        BYTE *pb =  NULL;
        pConfig->dwIDListOffset = pConfig->dwNumberListOffset
                                  + 1+cbNumber1+cbNumber2;

        // note:following macro assumes dwIDLIstOffset is already set.
        pb =  ISDN_IDS_FROM_CONFIG(pConfig);
        CopyMemory(pb,ID1, cbID1);

        if (dwNumEntries>1)
        {
            pb+=cbID1;
            CopyMemory(pb,ID2, cbID2);
        }
    }

end:

    return pConfig;
}


UINT GetNumEntries(
      IN  DWORD dwSwitchProps,
      IN  ISDN_STATIC_CAPS *pCaps,
      OUT BOOL *pfSetID
      )
{
    DWORD dwNumEntries = 0;
    BOOL fSetID = FALSE;

    if (!pCaps || !pfSetID) goto end;

    if (dwSwitchProps & USPROP)
    {
        dwNumEntries = pCaps->dwNumChannels;
        fSetID=TRUE;
    }
    else if (dwSwitchProps & MSNPROP)
    {
        dwNumEntries = pCaps->dwNumMSNs;
    }
    else if (dwSwitchProps & EAZPROP)
    {
        dwNumEntries = pCaps->dwNumEAZ;
        fSetID=TRUE;
    }

    //
    // Some switches only support one number/channel
    //
    if (dwSwitchProps & ONECH)
    {
        if (dwNumEntries>1)
        {
            dwNumEntries=1;
        }
    }

    // TODO: Our UI can't currently deal with more than 2
    if (dwNumEntries>2)
    {
        dwNumEntries=2;
    }

    *pfSetID = fSetID;

end:

    return dwNumEntries;

}


void InitSpidEaz (PCPLISDN this)
{
    TCHAR szTempBuf[LINE_LEN];
    int MaxLen;
    ISDN_STATIC_CONFIG *pConfig =
                         this->pmi->pglobal->pIsdnStaticConfig;
    UINT uSwitchType = (UINT)ComboBox_GetItemData(
                            this->hwndCB_ST,
                            ComboBox_GetCurSel(this->hwndCB_ST)
                            );

    BOOL fSetID=FALSE, fSetNumber=TRUE;
    UINT uNumEntries= GetNumEntries(
                          GetISDNSwitchTypeProps(uSwitchType),
                          this->pmi->pglobal->pIsdnStaticCaps,
                          &fSetID
                          );

    //
    // Set/clear the ID (spid/eaz) and number fields
    //

    switch (uSwitchType)
    {
        case dwISDN_SWITCH_1TR6:
            fSetNumber=FALSE;
            MaxLen = 2;
            break;

        case dwISDN_SWITCH_DMS100:
        case dwISDN_SWITCH_ATT1:
        case dwISDN_SWITCH_ATT_PTMP:
        case dwISDN_SWITCH_NI1:
            MaxLen = 20;
            break;

        case dwISDN_SWITCH_DSS1:
            MaxLen = 16;
            break;

        default:
            MaxLen = LINE_LEN-1;
    }

    if (uNumEntries)
    {
        //
        // Enable the 1st Number field.
        //
        if (fSetNumber)
        {
            EnableWindow(this->hwndEB_Number1, TRUE);
        }
        else
        {
            EnableWindow(this->hwndEB_Number1, FALSE);
        }

        if (fSetID)
        {
            //
            // Enable the 1st ID field.
            //
            EnableWindow(this->hwndEB_ID1, TRUE);
            Edit_GetText(this->hwndEB_ID1, szTempBuf, sizeof(szTempBuf)/sizeof(TCHAR));
            if (lstrlen (szTempBuf) > MaxLen)
            {
                Edit_SetText(this->hwndEB_ID1, TEXT(""));
            }
            Edit_LimitText(this->hwndEB_ID1, MaxLen);
        }
        else
        {
            //
            // Zap the 1st ID field.
            //
            SetWindowText(this->hwndEB_ID1, TEXT(""));
            EnableWindow(this->hwndEB_ID1, FALSE);
        }
    }
    else // no entries...
    {
        //
        // Zap the 1st ID and number field.
        //
        SetWindowText(this->hwndEB_ID1, TEXT(""));
        EnableWindow(this->hwndEB_ID1, FALSE);
        SetWindowText(this->hwndEB_Number1, TEXT(""));
        EnableWindow(this->hwndEB_Number1, FALSE);
    }

    if (uNumEntries>=2)
    {
        //
        // Enable the 2nd Number field.
        //
        if (fSetNumber)
        {
            EnableWindow(this->hwndEB_Number2, TRUE);
        }
        else
        {
            EnableWindow(this->hwndEB_Number2, FALSE);
        }

        if (fSetID)
        {
            //
            // Enable the 2nd ID field.
            //
            EnableWindow(this->hwndEB_ID2, TRUE);
            Edit_GetText(this->hwndEB_ID2, szTempBuf, sizeof(szTempBuf)/sizeof(TCHAR));
            if (lstrlen (szTempBuf) > MaxLen)
            {
                Edit_SetText(this->hwndEB_ID2, TEXT(""));
            }
            Edit_LimitText(this->hwndEB_ID2, MaxLen);
        }
        else
        {
            //
            // Zap the 2nd ID field.
            //
            SetWindowText(this->hwndEB_ID2, TEXT(""));
            EnableWindow(this->hwndEB_ID2, FALSE);
        }
    }
    else // < 2 entries
    {
        //
        // Zap the 2nd ID and number field.
        //
        SetWindowText(this->hwndEB_ID2, TEXT(""));
        EnableWindow(this->hwndEB_ID2, FALSE);
        SetWindowText(this->hwndEB_Number2, TEXT(""));
        EnableWindow(this->hwndEB_Number2, FALSE);
    }
}