//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1998.
//
//  File:       Settings.cpp
//
//  Contents:   Onestop settings routines
//
//  Classes:
//
//  Notes:
//
//  History:    10-Nov-97   SusiA      Created.
//
//--------------------------------------------------------------------------

#include "precomp.h"

extern HINSTANCE g_hmodThisDll; // Handle to this DLL itself.
extern UINT      g_cRefThisDll;
extern CRITICAL_SECTION g_DllCriticalSection; // Global Critical Section for this DLL

// items for context sensitive help
// Review -Should be string in resource.
TCHAR szSyncMgrHelp[]  = TEXT("mobsync.hlp");

ULONG g_aContextHelpIds[] =
{
    IDC_STATIC1,                ((DWORD)  -1),
    IDC_STATIC2,                ((DWORD)  -1),
    IDC_STATIC3,                ((DWORD)  -1),
    IDC_STATIC4,                ((DWORD)  -1),
    IDC_ADVANCEDIDLEOVERVIEWTEXT,           ((DWORD)  -1),
    IDC_ADVANCEDIDLEWAITTEXT,       ((DWORD)  -1),
    IDC_ADVANCEDIDLEMINUTESTEXT1,           ((DWORD)  -1),
    IDC_ADVANCEDIDLEMINUTESTEXT2,           ((DWORD)  -1),
    IDC_SP_SEPARATOR,           ((DWORD)  -1),
    IDS_CONNECTDESCRIPTION,         ((DWORD)  -1),
    IDC_SCHED_NAME,             ((DWORD)  -1),
    IDC_SCHED_STRING,           ((DWORD)  -1),
    IDC_LASTRUN,                ((DWORD)  -1),
    IDC_NEXTRUN,                ((DWORD)  -1),
        IDC_ConnectionText,                     ((DWORD)  -1),
    IDC_RUNLOGGEDON,            HIDC_RUNLOGGEDON,
    IDC_RUNALWAYS,              HIDC_RUNALWAYS,
    IDC_RUNAS_TEXT,             HIDC_RUNAS_TEXT,
    IDC_USERNAME,               HIDC_USERNAME,
    IDC_PASSWORD_TEXT,          HIDC_PASSWORD_TEXT,
    IDC_PASSWORD,               HIDC_PASSWORD,
    IDC_CONFIRMPASSWORD_TEXT,       HIDC_CONFIRMPASSWORD_TEXT,
    IDC_CONFIRMPASSWORD,            HIDC_CONFIRMPASSWORD,
    IDC_ADVANCEDIDLE,           HIDC_ADVANCEDIDLE,
    IDC_AUTOCONNECT,            HIDC_AUTOCONNECT,
    IDC_AUTOLOGOFF,             HIDC_AUTOLOGOFF,
    IDC_AUTOLOGON,              HIDC_AUTOLOGON,
    IDC_AUTOPROMPT_ME_FIRST,        HIDC_AUTOPROMPT_ME_FIRST,
    IDC_AUTOUPDATECOMBO,            HIDC_AUTOUPDATECOMBO,
    IDC_AUTOUPDATELIST,         HIDC_AUTOUPDATELIST,
    IDC_CHECKREPEATESYNC,           HIDC_CHECKREPEATESYNC,
    IDC_CHECKRUNONBATTERIES,        HIDC_CHECKRUNONBATTERIES,   
    IDC_EDITIDLEREPEATMINUTES,      HIDC_EDITIDLEREPEATMINUTES,
    IDC_EDITIWAITMINUTES,                   HIDC_EDITIWAITMINUTES,
        IDC_SPINIDLEREPEATMINUTES,              HIDC_EDITIDLEREPEATMINUTES,
    IDC_SPINIDLEWAITMINUTES,                HIDC_EDITIWAITMINUTES,
        IDC_IDLECHECKBOX,           HIDC_IDLECHECKBOX,
    IDC_SCHEDADD,               HIDC_SCHEDADD,
    IDC_SCHEDEDIT,              HIDC_SCHEDEDIT,
    IDC_SCHEDLIST,              HIDC_SCHEDLIST,
    IDC_SCHEDREMOVE,            HIDC_SCHEDREMOVE,
    IDC_SCHEDUPDATECOMBO,           HIDC_SCHEDUPDATECOMBO,  
    IDC_SCHEDUPDATELIST,            HIDC_SCHEDUPDATELIST,   
    IDC_SCHED_NAME_EDITBOX,         HIDC_SCHED_NAME_EDITBOX,
    0,0
};


INT_PTR CALLBACK AutoSyncDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam);
INT_PTR CALLBACK SchedSyncDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam);
INT_PTR CALLBACK IdleSyncDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam);
INT_PTR CALLBACK IdleAdvancedSettingsDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam);

int CALLBACK PropSheetProc( HWND hwndDlg, UINT uMsg, LPARAM lParam);

DWORD WINAPI  SettingsThread( LPVOID lpArg );

DWORD g_SettingsThreadID = NULL;
HWND g_hwndPropSheet = NULL;
CAutoSyncPage *g_pAutoSyncPage = NULL; // shared by AutoSync and IdleSyncDlg Procs
CSchedSyncPage *g_pSchedSyncPage = NULL;
BOOL g_fInSettingsDialog = FALSE;

//+-------------------------------------------------------------------------------
//
//  FUNCTION: IsSchedulingInstalled()
//
//  PURPOSE:  Determines is there is a task scheduler on the current workstation
//
//
//--------------------------------------------------------------------------------
BOOL IsSchedulingInstalled()
{
    BOOL fInstalled = FALSE;
    ISchedulingAgent *pSchedAgent = NULL;

    // Review if there is a better way to test this.
    if (NOERROR == CoCreateInstance(CLSID_CSchedulingAgent,
                                    NULL,
                                    CLSCTX_INPROC_SERVER,
                                    IID_ISchedulingAgent,
                                    (LPVOID*)&pSchedAgent))
    {
    fInstalled = TRUE;
    pSchedAgent->Release();
    }

    return fInstalled;
}

//+-------------------------------------------------------------------------------
//
//  FUNCTION: IsIdleAvailable()
//
//  PURPOSE:  Determines is this machine supports can Idle
//
//
//--------------------------------------------------------------------------------

BOOL IsIdleAvailable()
{
BOOL fInstalled = FALSE;
ISchedulingAgent *pSchedAgent = NULL;

    // Review if there is a better way to test this.
    if (NOERROR == CoCreateInstance(CLSID_CSchedulingAgent,
                                    NULL,
                                    CLSCTX_INPROC_SERVER,
                                    IID_ISchedulingAgent,
                                    (LPVOID*)&pSchedAgent) )
    {
    fInstalled = TRUE;
    pSchedAgent->Release();
    }

    return fInstalled;
}

//+-------------------------------------------------------------------------------
//
//  FUNCTION: IsAutoSyncAvailable()
//
//  PURPOSE:  Determines is this machine supports AutoSync
//
//
//--------------------------------------------------------------------------------

BOOL IsAutoSyncAvailable()
{
    return TRUE;
}

//+-------------------------------------------------------------------------------
//
//  FUNCTION: DisplayOptions()
//
//  PURPOSE:  Display the Onestop autosync options
//
//
//--------------------------------------------------------------------------------
STDAPI DisplayOptions(HWND hwndOwner)
{
#define MAXNUMPROPSHEETS 3
    
    int hr = E_FAIL;
    DWORD dwError;
    // always use ANSI versions since doesn't matter
    PROPSHEETPAGE psp [MAXNUMPROPSHEETS];
    HPROPSHEETPAGE hpsp [MAXNUMPROPSHEETS];
    PROPSHEETHEADER psh;
    int nPages = 0;
    BOOL fIdleAvailable;
    CCriticalSection cCritSect(&g_DllCriticalSection,GetCurrentThreadId());
    
    cCritSect.Enter();
    
    if (g_fInSettingsDialog) // IF ALREADY DISPLAYING A DIALOG BOX, THEN JUST RETURN
    {
        HWND hwndSettings = g_hwndPropSheet;
        
        cCritSect.Leave();
        
        if (hwndSettings)
        {
            SetForegroundWindow(hwndSettings);
        }
        
        return NOERROR;
    }
    
    
    g_fInSettingsDialog = TRUE;
    cCritSect.Leave();
    
    hr = CoInitialize(NULL);
    
    if (SUCCEEDED(hr))
    {
        
        RegSetUserDefaults(); // Make Sure the UserDefaults are up to date
        
        ZeroMemory(psp,sizeof(*psp));
        ZeroMemory(&psh, sizeof(psh));
        
        
        if (IsAutoSyncAvailable())
        {
            psp[nPages].dwSize = sizeof (psp[0]);
            psp[nPages].dwFlags = PSP_DEFAULT | PSP_USETITLE;
            psp[nPages].hInstance = g_hmodThisDll;
            psp[nPages].pszTemplate = MAKEINTRESOURCE(IDD_AUTOSYNC);
            psp[nPages].pszIcon = NULL;
            psp[nPages].pfnDlgProc = AutoSyncDlgProc;
            psp[nPages].pszTitle = MAKEINTRESOURCE(IDS_LOGONLOGOFF_TAB);
            psp[nPages].lParam = 0;
            
            hpsp[nPages] = CreatePropertySheetPage(&(psp[nPages]));
            ++nPages;
        }
        
        if (fIdleAvailable = IsIdleAvailable())
        {
            
            psp[nPages].dwSize = sizeof (psp[0]);
            psp[nPages].dwFlags = PSP_DEFAULT | PSP_USETITLE;
            
            psp[nPages].hInstance = g_hmodThisDll;
            psp[nPages].pszTemplate = MAKEINTRESOURCE(IDD_IDLESETTINGS);
            psp[nPages].pszIcon = NULL;
            psp[nPages].pfnDlgProc = IdleSyncDlgProc;
            psp[nPages].pszTitle = MAKEINTRESOURCE(IDS_ONIDLE_TAB);
            psp[nPages].lParam = 0;
            
            hpsp[nPages] = CreatePropertySheetPage(&(psp[nPages]));
            
            ++nPages;
        }
        
        
        // Review - if have idle have schedule, why not collapse
        // all these IsxxxAvailable into one call.
        if (fIdleAvailable /* IsSchedulingInstalled() */)
        {
            psp[nPages].dwSize = sizeof (psp[0]);
            psp[nPages].dwFlags = PSP_DEFAULT | PSP_USETITLE;
            psp[nPages].hInstance = g_hmodThisDll;
            psp[nPages].pszTemplate = MAKEINTRESOURCE(IDD_SCHEDSYNC);
            psp[nPages].pszIcon = NULL;
            psp[nPages].pfnDlgProc = SchedSyncDlgProc;
            psp[nPages].pszTitle = MAKEINTRESOURCE(IDS_SCHEDULED_TAB);
            psp[nPages].lParam = 0;
            
            hpsp[nPages] = CreatePropertySheetPage(&(psp[nPages]));
            
            ++nPages;
        }
        
        
        Assert(nPages <= MAXNUMPROPSHEETS);
        
        psh.dwSize = sizeof (psh);
        psh.dwFlags = PSH_DEFAULT | PSH_USECALLBACK | PSH_USEHICON;
        psh.hwndParent = hwndOwner;
        psh.hInstance = g_hmodThisDll;
        psh.pszIcon = NULL;
        psh.hIcon =  LoadIcon(g_hmodThisDll, MAKEINTRESOURCE(IDI_SYNCMGR));
        psh.pszCaption = MAKEINTRESOURCE(IDS_SCHEDULED_TITLE);
        psh.nPages = nPages;
        psh.phpage = hpsp;
        psh.pfnCallback = PropSheetProc;
        psh.nStartPage = 0;
        
        hr = (int)PropertySheet(&psh);
        
        // remove global classes
        
        if (g_pAutoSyncPage)
        {
            delete g_pAutoSyncPage;
            g_pAutoSyncPage = NULL;
        }
        
        g_SettingsThreadID = NULL;
        
        if (g_pSchedSyncPage)
        {
            delete g_pSchedSyncPage;
            g_pSchedSyncPage = NULL;
        }
        
        g_hwndPropSheet = NULL;
        
        CoFreeUnusedLibraries();
        CoUninitialize();
    }
    
    if (hr == -1)
    {
        dwError = GetLastError();
    }
    
    cCritSect.Enter();
    g_fInSettingsDialog = FALSE; // allow another settings to be created.
    cCritSect.Leave();
    
    return hr;
}


//+-------------------------------------------------------------------------------
//  FUNCTION: AutoSyncDlgProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE: Callback dialog procedure for the property page
//
//  PARAMETERS:
//    hDlg      - Dialog box window handle
//    uMessage  - current message
//    wParam    - depends on message
//    lParam    - depends on message
//
//  RETURN VALUE:
//
//    Depends on message.  In general, return TRUE if we process it.
//
//  COMMENTS:
//
//+-------------------------------------------------------------------------------

INT_PTR CALLBACK AutoSyncDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    WORD wNotifyCode = HIWORD(wParam); // notification code
    
    switch (uMessage)
    {
    case WM_INITDIALOG:
        {
            if (NULL == g_pAutoSyncPage)
            {
                g_pAutoSyncPage = new CAutoSyncPage(g_hmodThisDll);
            }
            
            if (g_pAutoSyncPage)
            {
                g_pAutoSyncPage->SetAutoSyncHwnd(hDlg);
                g_pAutoSyncPage->InitializeHwnd(hDlg,SYNCTYPE_AUTOSYNC,0);
                return TRUE;
            }   
            else
            {
                return FALSE;
            }
        }
        break;
        
    case WM_DESTROY:
        {
            
            if (g_pAutoSyncPage && g_pAutoSyncPage->m_pItemListViewAutoSync)
            {
                delete  g_pAutoSyncPage->m_pItemListViewAutoSync;
                g_pAutoSyncPage->m_pItemListViewAutoSync = NULL;
            }
            
        }
        break;
        
    case WM_COMMAND:
        switch (LOWORD(wParam))
        {
        case IDC_AUTOUPDATECOMBO:
            {
                if (wNotifyCode == CBN_SELCHANGE)
                {
                    HWND hwndCombo = (HWND) lParam;
                    if (g_pAutoSyncPage)
                    {
                        g_pAutoSyncPage->ShowItemsOnThisConnection
                            (hDlg,SYNCTYPE_AUTOSYNC,ComboBox_GetCurSel(hwndCombo));
                    }
                }
            }
            break;
            
        case IDC_AUTOLOGON: 
        case IDC_AUTOLOGOFF:
        case IDC_AUTOPROMPT_ME_FIRST:
            {
                if (wNotifyCode == BN_CLICKED)
                {
                    PropSheet_Changed(g_hwndPropSheet, hDlg);
                    
                    HWND hwndCtrl = (HWND) lParam;
                    g_pAutoSyncPage->SetConnectionCheck(hDlg,SYNCTYPE_AUTOSYNC,LOWORD(wParam),
                        Button_GetCheck(hwndCtrl));
                    
                }
            }
            break;
            
        default:
            break;
            
        }
        break;
        case WM_HELP:
            {
                LPHELPINFO lphi  = (LPHELPINFO)lParam;
                
                if (lphi->iContextType == HELPINFO_WINDOW)
                {
                    WinHelp ( (HWND) lphi->hItemHandle,
                        szSyncMgrHelp,
                        HELP_WM_HELP,
                        (ULONG_PTR) g_aContextHelpIds);
                }
                return TRUE;
            }
        case WM_CONTEXTMENU:
            {
                
                WinHelp ((HWND)wParam,
                    szSyncMgrHelp,
                    HELP_CONTEXTMENU,
                    (ULONG_PTR)g_aContextHelpIds);
                
                return TRUE;
            }
            
        case WM_NOTIFYLISTVIEWEX:
            
            if (g_pAutoSyncPage)
            {
                int idCtrl = (int) wParam;
                LPNMHDR pnmhdr = (LPNMHDR) lParam;
                
                if ( (IDC_AUTOUPDATELIST != idCtrl) || (NULL == g_pAutoSyncPage->m_pItemListViewAutoSync))
                {
                    Assert(IDC_AUTOUPDATELIST == idCtrl);
                    Assert(g_pAutoSyncPage->m_pItemListViewAutoSync);
                    break;
                }
                
                switch (pnmhdr->code)
                {
                case LVNEX_ITEMCHECKCOUNT:
                    {
                        LPNMLISTVIEWEXITEMCHECKCOUNT pnmvCheckCount = (LPNMLISTVIEWEXITEMCHECKCOUNT) lParam;
                        
                        // pass along notification only if listView is done being initialized
                        // since no need to set the CheckState or mark PSheet as Dirty
                        if (g_pAutoSyncPage->m_pItemListViewAutoSyncInitialized)
                        {
                            
                            g_pAutoSyncPage->SetItemCheckState(hDlg,SYNCTYPE_AUTOSYNC,
                                pnmvCheckCount->iItemId,pnmvCheckCount->dwItemState
                                ,pnmvCheckCount->iCheckCount);
                            
                            PropSheet_Changed(g_hwndPropSheet, hDlg);
                        }
                        
                        break;
                    }
                default:
                    break;
                }
            }
            break;
            
        case WM_NOTIFY:
            if (g_pAutoSyncPage)
            {
                int idCtrl = (int) wParam;
                LPNMHDR pnmhdr = (LPNMHDR) lParam;
                
                
                // if notification for UpdateListPass it on.
                if ((IDC_AUTOUPDATELIST == idCtrl) && g_pAutoSyncPage->m_pItemListViewAutoSync)
                {
                    g_pAutoSyncPage->m_pItemListViewAutoSync->OnNotify(pnmhdr);
                    break;
                }
                
            }
            
            switch (((NMHDR FAR *)lParam)->code)
            {
            case PSN_SETACTIVE:
                break;
                
            case PSN_APPLY:
                //User has clicked the OK or Apply button so we'll
                //Save the current selections
                
                g_pAutoSyncPage->CommitAutoSyncChanges();
                break;
            default:
                break;
            }
            break;
            
            default:
                return FALSE;
    }
    
    return FALSE;
}


//+-------------------------------------------------------------------------------
//  FUNCTION: IdleSyncDlgProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE: Callback dialog procedure for the iDLE property page
//
//  PARAMETERS:
//    hDlg      - Dialog box window handle
//    uMessage  - current message
//    wParam    - depends on message
//    lParam    - depends on message
//
//  RETURN VALUE:
//
//    Depends on message.  In general, return TRUE if we process it.
//
//  COMMENTS:
//
//+-------------------------------------------------------------------------------

INT_PTR CALLBACK IdleSyncDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    WORD wNotifyCode = HIWORD(wParam); // notification code
    
    switch (uMessage)
    {
    case WM_INITDIALOG:
        {
        /*
        RECT rc;
        HRESULT hr;
        
          
            hr = GetWindowRect(hDlg, &rc);
            
              hr = SetWindowPos(hDlg,
              NULL,
              ((GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left)) / 2),
              ((GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top)) / 2),
              0,
              0,
            SWP_NOSIZE | SWP_NOACTIVATE); */
            
            
            if (NULL == g_pAutoSyncPage)
            {
                g_pAutoSyncPage = new CAutoSyncPage(g_hmodThisDll);
            }
            
            
            if (g_pAutoSyncPage)
            {
                BOOL fConnectionsAvailable;
                
                g_pAutoSyncPage->SetIdleHwnd(hDlg);
                g_pAutoSyncPage->InitializeHwnd(hDlg,SYNCTYPE_IDLE,0);
                
                // there must be at least one connection or we disable
                // the advanced button.
                
                fConnectionsAvailable  =
                    g_pAutoSyncPage->GetNumConnections(hDlg,SYNCTYPE_IDLE)
                    ? TRUE : FALSE;
                
                EnableWindow(GetDlgItem(hDlg,IDC_ADVANCEDIDLE),fConnectionsAvailable);
                
                return TRUE;
            }   
            else
            {
                return FALSE;
            }
            
        }
        break;
    case WM_DESTROY:
        {
            
            if (g_pAutoSyncPage && g_pAutoSyncPage->m_pItemListViewIdle)
            {
                delete g_pAutoSyncPage->m_pItemListViewIdle;
                g_pAutoSyncPage->m_pItemListViewIdle = NULL;
            }
            
            //  PostQuitMessage(0); 
            
            // PostQuitMessage(0);  
        }
        break;
    case WM_HELP:
        {
            LPHELPINFO lphi  = (LPHELPINFO)lParam;
            
            if (lphi->iContextType == HELPINFO_WINDOW)
            {
                WinHelp ( (HWND) lphi->hItemHandle,
                    szSyncMgrHelp,
                    HELP_WM_HELP,
                    (ULONG_PTR) g_aContextHelpIds);
            }
            return TRUE;
        }
    case WM_CONTEXTMENU:
        {
            
            WinHelp ((HWND)wParam,
                szSyncMgrHelp,
                HELP_CONTEXTMENU,
                (ULONG_PTR)g_aContextHelpIds);
            
            return TRUE;
        }
    case WM_COMMAND:
        switch (LOWORD(wParam))
        {
        case IDC_AUTOUPDATECOMBO:
            {
                if (wNotifyCode == CBN_SELCHANGE)
                {
                    HWND hwndCombo = (HWND) lParam;
                    if (g_pAutoSyncPage)
                    {
                        g_pAutoSyncPage->ShowItemsOnThisConnection
                            (hDlg,SYNCTYPE_IDLE,ComboBox_GetCurSel(hwndCombo));
                    }
                }
            }
            break;
        case IDC_IDLECHECKBOX:
            {
                if (wNotifyCode == BN_CLICKED)
                {
                    PropSheet_Changed(g_hwndPropSheet, hDlg);
                    
                    HWND hwndCtrl = (HWND) lParam;
                    g_pAutoSyncPage->SetConnectionCheck(hDlg,SYNCTYPE_IDLE,LOWORD(wParam),
                        Button_GetCheck(hwndCtrl));
                    
                }
            }
            break;
        case IDC_ADVANCEDIDLE:
            {
                if (wNotifyCode == BN_CLICKED)
                {
                    // bring up the advanced idle dialog passing in the autoSyncPage class
                    // as the owning class.
                    DialogBoxParam(g_hmodThisDll,
                        MAKEINTRESOURCE(IDD_ADVANCEDIDLESETTINGS),hDlg, IdleAdvancedSettingsDlgProc,
                        (LPARAM) g_pAutoSyncPage);
                    
                }
            }
            break;
        default:
            break;
            
        }
        break;
        case WM_NOTIFYLISTVIEWEX:
            if (g_pAutoSyncPage)
            {
                int idCtrl = (int) wParam;
                LPNMHDR pnmhdr = (LPNMHDR) lParam;
                
                if ( (IDC_AUTOUPDATELIST != idCtrl) || (NULL == g_pAutoSyncPage->m_pItemListViewIdle))
                {
                    Assert(IDC_AUTOUPDATELIST == idCtrl);
                    Assert(g_pAutoSyncPage->m_pItemListViewIdle);
                    break;
                }
                
                switch (pnmhdr->code)
                {
                case LVNEX_ITEMCHECKCOUNT:
                    {
                        LPNMLISTVIEWEXITEMCHECKCOUNT pnmvCheckCount = (LPNMLISTVIEWEXITEMCHECKCOUNT) lParam;
                        
                        // pass along notification only if listView is done being initialized
                        // since no need to set the CheckState or mark PSheet as Dirty
                        if (g_pAutoSyncPage->m_fListViewIdleInitialized)
                        {
                            g_pAutoSyncPage->SetItemCheckState(hDlg,SYNCTYPE_IDLE,
                                pnmvCheckCount->iItemId,pnmvCheckCount->dwItemState
                                ,pnmvCheckCount->iCheckCount);
                            
                            PropSheet_Changed(g_hwndPropSheet, hDlg);
                        }
                        
                        break;
                    }
                default:
                    break;
                }
            }
            break;
        case WM_NOTIFY:
            
            if (g_pAutoSyncPage)
            {
                int idCtrl = (int) wParam;
                LPNMHDR pnmhdr = (LPNMHDR) lParam;
                
                // if notification for UpdateListPass it on.
                if ((IDC_AUTOUPDATELIST == idCtrl) && g_pAutoSyncPage->m_pItemListViewIdle)
                {
                    g_pAutoSyncPage->m_pItemListViewIdle->OnNotify(pnmhdr);
                    break;
                }
                
                switch (((NMHDR FAR *)lParam)->code)
                {
                case PSN_SETACTIVE:
                    break;
                case PSN_APPLY:
                    //User has clicked the OK or Apply button so we'll
                    //Save the current selections
                    g_pAutoSyncPage->CommitIdleChanges();
                    break;
                default:
                    break;
                }
            }
            break;
            
        default:
            return FALSE;
    }
    
    return FALSE;
}

//+-------------------------------------------------------------------------------
//  FUNCTION: IdleAdvancedSettingsDlgProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE: Callback dialog procedure for the Advanced Idle Settings.
//
//  PARAMETERS:
//    hDlg      - Dialog box window handle
//    uMessage  - current message
//    wParam    - depends on message
//    lParam    - depends on message
//
//  RETURN VALUE:
//
//    Depends on message.  In general, return TRUE if we process it.
//
//  COMMENTS:
//
//+-------------------------------------------------------------------------------


INT_PTR CALLBACK IdleAdvancedSettingsDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    
    switch(uMessage)
    {
    case WM_INITDIALOG:
        {
            CONNECTIONSETTINGS ConnectionSettings;
            
            Assert(g_pAutoSyncPage);
            
            if (NULL == g_pAutoSyncPage)
                return FALSE;
            
            UpDown_SetRange(GetDlgItem(hDlg,IDC_SPINIDLEWAITMINUTES), SPINDIALWAITMINUTES_MIN, SPINDIALWAITMINUTES_MAX);
            Edit_LimitText(GetDlgItem(hDlg,IDC_EDITIWAITMINUTES), 3);
            
            UpDown_SetRange(GetDlgItem(hDlg,IDC_SPINIDLEREPEATMINUTES), SPINDIALREPEATMINUTES_MIN, SPINDIALREPEATMINUTES_MAX);
            Edit_LimitText(GetDlgItem(hDlg,IDC_EDITIDLEREPEATMINUTES), 3);
            
            // initialize user specific preferences
            // if can't get shouldn't show dialog
            
            // EditText cannot accept DBCS characters on Win9x so disalbe IME for 
            // Edit Boxes.
            
            ImmAssociateContext(GetDlgItem(hDlg,IDC_EDITIWAITMINUTES), NULL);
            ImmAssociateContext(GetDlgItem(hDlg,IDC_EDITIDLEREPEATMINUTES), NULL);
            
            if (NOERROR == g_pAutoSyncPage->GetAdvancedIdleSettings(&ConnectionSettings))
            {
                UpDown_SetPos(GetDlgItem(hDlg,IDC_SPINIDLEWAITMINUTES), ConnectionSettings.ulIdleWaitMinutes);
                UpDown_SetPos(GetDlgItem(hDlg,IDC_SPINIDLEREPEATMINUTES),ConnectionSettings.ulIdleRetryMinutes);
                
                Button_SetCheck(GetDlgItem(hDlg,IDC_CHECKREPEATESYNC),ConnectionSettings.dwRepeatSynchronization);
                Button_SetCheck(GetDlgItem(hDlg,IDC_CHECKRUNONBATTERIES),!(ConnectionSettings.dwRunOnBatteries));
                
                // if the repeat check state is selected then enable the edit box associated with it
                EnableWindow(GetDlgItem(hDlg,IDC_SPINIDLEREPEATMINUTES),ConnectionSettings.dwRepeatSynchronization);
                EnableWindow(GetDlgItem(hDlg,IDC_EDITIDLEREPEATMINUTES),ConnectionSettings.dwRepeatSynchronization);
                EnableWindow(GetDlgItem(hDlg,IDC_ADVANCEDIDLEMINUTESTEXT2),ConnectionSettings.dwRepeatSynchronization);
                
            }
            
            ShowWindow(hDlg,SW_SHOW);
            return TRUE;
            break;
        }
    case WM_HELP:
        {
            LPHELPINFO lphi  = (LPHELPINFO)lParam;
            
            if (lphi->iContextType == HELPINFO_WINDOW)
            {
                WinHelp ( (HWND) lphi->hItemHandle,
                    szSyncMgrHelp,
                    HELP_WM_HELP,
                    (ULONG_PTR) g_aContextHelpIds);
            }
            return TRUE;
        }
    case WM_CONTEXTMENU:
        {
            
            WinHelp ((HWND)wParam,
                szSyncMgrHelp,
                HELP_CONTEXTMENU,
                (ULONG_PTR)g_aContextHelpIds);
            
            return TRUE;
        }
    case WM_COMMAND:
        switch (LOWORD(wParam))
        {
        case IDCANCEL:
            EndDialog(hDlg,FALSE);
            break;
        case IDOK:
            if (g_pAutoSyncPage)
            {
                CONNECTIONSETTINGS ConnectionSettings;
                
                if (g_pAutoSyncPage)
                {
                    
                    ConnectionSettings.ulIdleWaitMinutes = GetDlgItemInt(hDlg, IDC_EDITIWAITMINUTES, NULL, FALSE);
                    ConnectionSettings.ulIdleRetryMinutes = GetDlgItemInt(hDlg, IDC_EDITIDLEREPEATMINUTES, NULL, FALSE);
                    
                    ConnectionSettings.dwRepeatSynchronization = Button_GetCheck(GetDlgItem(hDlg,IDC_CHECKREPEATESYNC));
                    ConnectionSettings.dwRunOnBatteries = (!Button_GetCheck(GetDlgItem(hDlg,IDC_CHECKRUNONBATTERIES)));
                    
                    g_pAutoSyncPage->SetAdvancedIdleSettings(&ConnectionSettings);
                }
            }
            EndDialog(hDlg,FALSE);
            break;
        case IDC_EDITIWAITMINUTES:
            {
                WORD wNotifyCode = HIWORD(wParam);
                INT iNewPos;
                
                //
                // If the user just pasted non-numeric text or an illegal numeric
                // value, overwrite it and complain.
                //
                if (EN_KILLFOCUS == wNotifyCode)
                {
                    iNewPos = GetDlgItemInt(hDlg, IDC_EDITIWAITMINUTES, NULL, FALSE);
                    if (iNewPos < SPINDIALWAITMINUTES_MIN || iNewPos > SPINDIALWAITMINUTES_MAX)
                    {
                        HWND hUD = GetDlgItem(hDlg,IDC_SPINIDLEWAITMINUTES);
                        
                        if (iNewPos < SPINDIALWAITMINUTES_MIN)
                        {
                            UpDown_SetPos(hUD, SPINDIALWAITMINUTES_MIN);
                        }
                        else
                        {
                            UpDown_SetPos(hUD,SPINDIALWAITMINUTES_MAX);
                        }
                        
                    }
                    
                }
                break;
            }
        case IDC_EDITIDLEREPEATMINUTES:
            {
                WORD wNotifyCode = HIWORD(wParam);
                INT iNewPos;
                
                //
                // If the user just pasted non-numeric text or an illegal numeric
                // value, overwrite it and complain.
                //
                
                // Review, redundant code with other spin control.
                if (EN_KILLFOCUS  == wNotifyCode)
                {
                    iNewPos = GetDlgItemInt(hDlg, IDC_EDITIDLEREPEATMINUTES, NULL, FALSE);
                    if (iNewPos < SPINDIALREPEATMINUTES_MIN || iNewPos > SPINDIALREPEATMINUTES_MAX)
                    {
                        HWND hUD = GetDlgItem(hDlg,IDC_SPINIDLEREPEATMINUTES);
                        
                        if (iNewPos < SPINDIALREPEATMINUTES_MIN)
                        {
                            UpDown_SetPos(hUD, SPINDIALREPEATMINUTES_MIN);
                        }
                        else
                        {
                            UpDown_SetPos(hUD,SPINDIALREPEATMINUTES_MAX);
                        }
                        
                    }
                    
                }
                
                break;
            }
        case IDC_CHECKREPEATESYNC:
            {
                WORD wNotifyCode = HIWORD(wParam);
                
                // if use clicked the repeat check box set set state of the other
                // items associated with it.
                
                if (BN_CLICKED == wNotifyCode)
                {
                    BOOL fEnableState = Button_GetCheck(GetDlgItem(hDlg,IDC_CHECKREPEATESYNC));
                    
                    // if the repeat check state is selected then enable the edit box associated with it
                    EnableWindow(GetDlgItem(hDlg,IDC_SPINIDLEREPEATMINUTES),fEnableState);
                    EnableWindow(GetDlgItem(hDlg,IDC_EDITIDLEREPEATMINUTES),fEnableState);
                    EnableWindow(GetDlgItem(hDlg,IDC_ADVANCEDIDLEMINUTESTEXT2),fEnableState);
                }
                
                
                break;
            }
        default:
            break;
        }
    default:
        break;
    }
    
    return FALSE;
}


//+-------------------------------------------------------------------------------
//  FUNCTION: SchedSyncDlgProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE: Callback dialog procedure for the property page
//
//  PARAMETERS:
//    hDlg      - Dialog box window handle
//    uMessage  - current message
//    wParam    - depends on message
//    lParam    - depends on message
//
//  RETURN VALUE:
//
//    Depends on message.  In general, return TRUE if we process it.
//
//  COMMENTS:
//
//--------------------------------------------------------------------------------


INT_PTR CALLBACK SchedSyncDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    WORD wNotifyCode = HIWORD(wParam); // notification code
    BOOL bResult = FALSE;
    
    switch (uMessage)
    {
    case WM_INITDIALOG:
        {
            
            g_pSchedSyncPage = new CSchedSyncPage(g_hmodThisDll, hDlg);
            
            if (g_pSchedSyncPage)
            {
                bResult =  g_pSchedSyncPage->Initialize();
            }   
            
        }
        break;
    case WM_DESTROY:
        {
            g_pSchedSyncPage->FreeAllSchedules();
        }
        break;
    case WM_HELP:
        {
            LPHELPINFO lphi  = (LPHELPINFO)lParam;
            
            if (lphi->iContextType == HELPINFO_WINDOW)
            {
                WinHelp ( (HWND) lphi->hItemHandle,
                    szSyncMgrHelp,
                    HELP_WM_HELP,
                    (ULONG_PTR) g_aContextHelpIds);
            }
            
            bResult = TRUE;
        }
        break;
    case WM_CONTEXTMENU:
        {
            WinHelp ((HWND)wParam,
                szSyncMgrHelp,
                HELP_CONTEXTMENU,
                (ULONG_PTR)g_aContextHelpIds);
            
            bResult =  TRUE;
        }
        break;
    case WM_NOTIFY:
        switch (((NMHDR FAR *)lParam)->code)
        {
        case PSN_SETACTIVE:
            break;
            
        case PSN_APPLY:
            //User has clicked the OK or Apply button so we'll
            //update the icon information in the .GAK file
            break;
            
        default:
            bResult =  g_pSchedSyncPage->OnNotify(hDlg,(int)wParam,(LPNMHDR)lParam);
            break;
        }
        break;
        case WM_COMMAND:
            bResult = g_pSchedSyncPage->OnCommand(hDlg, HIWORD(wParam), LOWORD(wParam),
                (HWND)lParam);
            break;  
        default:
            break;
    }
    
    return bResult;
}
//+-------------------------------------------------------------------------------
//
//  FUNCTION: CALLBACK PropSheetProc( HWND hwndDlg, UINT uMsg, LPARAM lParam);
//
//  PURPOSE: Callback dialog init procedure the settings property dialog
//
//  PARAMETERS:
//    hwndDlg   - Dialog box window handle
//    uMsg      - current message
//    lParam    - depends on message
//
//--------------------------------------------------------------------------------

int CALLBACK PropSheetProc( HWND hwndDlg, UINT uMsg, LPARAM lParam)
{
    switch(uMsg)
    {
    case PSCB_INITIALIZED:
        g_hwndPropSheet = hwndDlg;
        return TRUE;
        break;
    default:
        return TRUE;
    }
    return TRUE;
    
}