windows-xp/Source/XPSP1/NT/shell/cpls/inetcpl/security.cpp

//*********************************************************************
//*          Microsoft Windows                                       **
//*        Copyright(c) Microsoft Corp., 1995                        **
//*********************************************************************

//
// SECURITY.cpp - "Security" Property Sheet
//

// HISTORY:
//
// 6/22/96  t-gpease    moved to this file
// 5/14/97  t-ashlm     new dialog

#include "inetcplp.h"
#include "inetcpl.h"   // for LSDFLAGS
#include "intshcut.h"
#include "permdlg.h"   // java permissions
#include "pdlgguid.h"  // guids for Java VM permissions dlg
#include <cryptui.h>

#include <mluisupp.h>

void LaunchSecurityDialogEx(HWND hDlg, DWORD dwZone, BOOL bForceUI, BOOL bDisableAddSites);

//
// Private Functions and Structures
//
INT_PTR CALLBACK SecurityAddSitesDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
INT_PTR CALLBACK SecurityCustomSettingsDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
INT_PTR CALLBACK SecurityAddSitesIntranetDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
void SecurityChanged();

TCHAR *MyIntToStr(TCHAR *pBuf, BYTE iVal);
BOOL SecurityDlgInit(HWND hDlg);


#define WIDETEXT(x) L ## x
#define REGSTR_PATH_SECURITY_LOCKOUT  TEXT("Software\\Policies\\Microsoft\\Windows\\CurrentVersion\\Internet Settings")
#define REGSTR_VAL_OPTIONS_EDIT       TEXT("Security_options_edit")
#define REGSTR_VAL_ZONES_MAP_EDIT     TEXT("Security_zones_map_edit")
#define REGSTR_VAL_HKLM_ONLY          TEXT("Security_HKLM_only")
#define REGSTR_PATH_SO                TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\SO")
#define REGSTR_PATH_SOIEAK            TEXT("Sofwtare\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\SOIEAK")

///////////////////////////////////////////////////////////////////////////////////////
//
// Structures
//
///////////////////////////////////////////////////////////////////////////////////////

typedef struct tagSECURITYZONESETTINGS
{
    BOOL    dwFlags;            // from the ZONEATTRIBUTES struct
    DWORD   dwZoneIndex;        // as defined by ZoneManager
    DWORD   dwSecLevel;         // current level (High, Medium, Low, Custom)
    DWORD   dwPrevSecLevel;
    DWORD   dwMinSecLevel;      // current min level (High, Medium, Low, Custom)
    DWORD   dwRecSecLevel;      // current recommended level (High, Medium, Low, Custom)
    TCHAR   szDescription[MAX_ZONE_DESCRIPTION];
    TCHAR   szDisplayName[MAX_ZONE_PATH];
    HICON   hicon;
} SECURITYZONESETTINGS, *LPSECURITYZONESETTINGS;

// structure for main security page
typedef struct tagSECURITYPAGE
{
    HWND                    hDlg;                   // handle to window
    LPURLZONEMANAGER        pInternetZoneManager;   // pointer to InternetZoneManager
    IInternetSecurityManager *pInternetSecurityManager; // pointer to InternetSecurityManager
    HIMAGELIST              himl;                   // imagelist for Zones combobox
    HWND                    hwndZones;              // zones combo box hwnd
    LPSECURITYZONESETTINGS  pszs;                   // current settings for displayed zone
    INT                     iZoneSel;               // selected zone (as defined by ComboBox)
    DWORD                   dwZoneCount;            // number of zones
    BOOL                    fChanged;
    BOOL                    fPendingChange;         // to prevent the controls sending multiple sets (for cancel, mostly)
    HINSTANCE               hinstUrlmon;
    BOOL                    fNoEdit;                // hklm lockout of level edit
    BOOL                    fNoAddSites;            // hklm lockout of addsites
    BOOL                    fNoZoneMapEdit;         // hklm lockout of zone map edits
    HFONT                   hfontBolded;            // special bolded font created for the zone title
    BOOL                    fForceUI;               // Force every zone to show ui?
    BOOL                    fDisableAddSites;       // Automatically diable add sites button?
} SECURITYPAGE, *LPSECURITYPAGE;

// structure for Intranet Add Sites
typedef struct tagADDSITESINTRANETINFO {
    HWND hDlg;                                      // handle to window
    BOOL fUseIntranet;                              // Use local defined intranet addresses (in reg)
    BOOL fUseProxyExclusion;                        // Use proxy exclusion list
    BOOL fUseUNC;                                   // Include UNC in intranet
    LPSECURITYPAGE pSec;            
} ADDSITESINTRANETINFO, *LPADDSITESINTRANETINFO;

// structure for Add Sites
typedef struct tagADDSITESINFO {
    HWND hDlg;                                      // handle to window
    BOOL fRequireServerVerification;                // Require Server Verification on sites in zone
    HWND hwndWebSites;                              // handle to list
    HWND hwndAdd;                                   // handle to edit
    TCHAR szWebSite[MAX_ZONE_PATH];                 // text in edit control
    BOOL fRSVOld;
    LPSECURITYPAGE pSec;            
} ADDSITESINFO, *LPADDSITESINFO;

// structure for Custom Settings 
typedef struct tagCUSTOMSETTINGSINFO {
    HWND  hDlg;                                     // handle to window
    HWND hwndTree;

    LPSECURITYPAGE pSec;
    HWND hwndCombo;
    INT iLevelSel;
    IRegTreeOptions *pTO;
    BOOL fUseHKLM;          // get/set settings from HKLM
    DWORD dwJavaPolicy;     // Java policy selected
    BOOL fChanged;
} CUSTOMSETTINGSINFO, *LPCUSTOMSETTINGSINFO;


BOOL SecurityEnableControls(LPSECURITYPAGE pSec, BOOL fSetFocus);
BOOL SecurityDlgApplyNow(LPSECURITYPAGE pSec, BOOL bPrompt);


// global variables
extern DWORD g_dwtlsSecInitFlags;

extern BOOL g_fSecurityChanged; // flag indicating that Active Security has changed.

//////////////////////////////////////////////////////////////////////////////
//
// Main Security Page Helper Functions
//
//////////////////////////////////////////////////////////////////////////////

#define NUM_TEMPLATE_LEVELS      4
TCHAR g_szLevel[3][64];
TCHAR LEVEL_DESCRIPTION0[300];
TCHAR LEVEL_DESCRIPTION1[300];
TCHAR LEVEL_DESCRIPTION2[300];
TCHAR LEVEL_DESCRIPTION3[300];
LPTSTR LEVEL_DESCRIPTION[NUM_TEMPLATE_LEVELS] = {
    LEVEL_DESCRIPTION0,
    LEVEL_DESCRIPTION1,
    LEVEL_DESCRIPTION2,
    LEVEL_DESCRIPTION3
};
TCHAR CUSTOM_DESCRIPTION[300];

TCHAR LEVEL_NAME0[30];
TCHAR LEVEL_NAME1[30];
TCHAR LEVEL_NAME2[30];
TCHAR LEVEL_NAME3[30];
LPTSTR LEVEL_NAME[NUM_TEMPLATE_LEVELS] = {
    LEVEL_NAME0,
    LEVEL_NAME1,
    LEVEL_NAME2,
    LEVEL_NAME3
};
TCHAR CUSTOM_NAME[30];

// Some accessibility related prototypes.

// Our override of the slider window proc. 
LRESULT CALLBACK SliderSubWndProc (HWND hwndSlider, UINT uMsg, WPARAM wParam, LPARAM lParam, WPARAM uID, ULONG_PTR dwRefData );

extern BOOL g_fAttemptedOleAccLoad ;
extern HMODULE g_hOleAcc;


// Can't find value for WM_GETOBJECT in the headers. Need to figure out the right header to include
// here. 
#ifndef WM_GETOBJECT
#define WM_GETOBJECT        0x03d
#endif

// Prototype for CreateStdAccessibleProxy.
// A and W versions are available - pClassName can be ANSI or UNICODE
// string. This is a TCHAR-style prototype, but you can do a A or W
// specific one if desired.
typedef HRESULT (WINAPI *PFNCREATESTDACCESSIBLEPROXY) (
    HWND     hWnd,
    LPTSTR   pClassName,
    LONG     idObject,
    REFIID   riid,
    void **  ppvObject 
    );
/*
 * Arguments:
 *
 * HWND hWnd
 *   Handle of window to return IAccessible for.
 *
 * LPTSTR pClassName
 *   Class name indicating underlying class of the window. For
 *   example, if "LISTBOX" is used here, the returned object will
 *   behave appropriately for a listbox, and will expect the given
 *   hWnd to support listbox messages and styles. This argument
 *   nearly always reflects the window class from which the control
 *   is derived.
 *
 * LONG idObject
 *   Always OBJID_CLIENT
 *
 * REFIID riid
 *   Always IID_IAccessible
 *
 * void ** ppvObject
 *   Out pointer used to return an IAccessible to a newly-created
 *   object which represents the control hWnd as though it were of
 *   window class pClassName.
 *
 * If successful,
 * returns S_OK, *ppvObject != NULL;
 * otherwise returns error HRESULT.
 *
 *
 */



// Same for LresultFromObject...
typedef LRESULT (WINAPI *PFNLRESULTFROMOBJECT)(
    REFIID riid,
    WPARAM wParam,
    LPUNKNOWN punk 
    );


PRIVATE PFNCREATESTDACCESSIBLEPROXY s_pfnCreateStdAccessibleProxy = NULL;
PRIVATE PFNLRESULTFROMOBJECT s_pfnLresultFromObject = NULL;

// Simple accessibility wrapper class which returns the right string values

class CSecurityAccessibleWrapper: public CAccessibleWrapper
{
                // Want to remember the hwnd of the trackbar...
                HWND m_hWnd;
public:
                CSecurityAccessibleWrapper( HWND hWnd, IAccessible * pAcc );
               ~CSecurityAccessibleWrapper();

                STDMETHODIMP get_accValue(VARIANT varChild, BSTR* pszValue);
};

// Ctor - pass through the IAccessible we're wrapping to the
// CAccessibleWrapper base class; also remember the trackbar hwnd.
CSecurityAccessibleWrapper::CSecurityAccessibleWrapper( HWND hWnd, IAccessible * pAcc )
    : CAccessibleWrapper( pAcc ),
      m_hWnd( hWnd )

{
    // Do nothing
}

// Nothing to do here - but if we do need to do cleanup, this is the
// place for it.
CSecurityAccessibleWrapper::~CSecurityAccessibleWrapper()
{
    // Do nothing
}


// Overridden get_accValue method...
STDMETHODIMP   CSecurityAccessibleWrapper::get_accValue(VARIANT varChild, BSTR* pszValue)
{
    // varChild.lVal specifies which sub-part of the component
    // is being queried.
    // CHILDID_SELF (0) specifies the overall component - other
    // non-0 values specify a child.

    // In a trackbar, CHILDID_SELF refers to the overall trackbar
    // (which is what we want), whereas other values refer to the
    // sub-components - the actual slider 'thumb', and the 'page
    // up/page down' areas to the left/right of it.
    if( varChild.vt == VT_I4 && varChild.lVal == CHILDID_SELF )
    {
        // Get the scrollbar value...
        int iPos = (int)SendMessage( m_hWnd, TBM_GETPOS , 0, 0 );

        // Check that it's in range...
        // (It's possible that we may get this request after the
        // trackbar has been created, bu before we've set it to
        // a meaningful value.)
        if( iPos < 0 || iPos >= NUM_TEMPLATE_LEVELS )
        {
            TCHAR rgchUndefined[40];
            int cch = MLLoadString(IDS_TEMPLATE_NAME_UNDEFINED, rgchUndefined, ARRAYSIZE(rgchUndefined));
            if (cch != 0)
            {
                *pszValue = SysAllocString(rgchUndefined);
            }
            else
            {
                // Load String failed, for some reason.
                return HRESULT_FROM_WIN32(GetLastError());
            }
    
        }
        else
        {
            *pszValue = SysAllocString( LEVEL_NAME[iPos]);
        }
        
        // All done!
        return S_OK;

    }
    else
    {
        // Pass requests about the sub-components to the
        // base class (which will forward to the 'original'
        // IAccessible for us).
        return CAccessibleWrapper::get_accValue(varChild, pszValue);
    }
}


// Converting the Security Level DWORD identitifiers to slider levels, and vice versa
int SecLevelToSliderPos(DWORD dwLevel)
{
    switch(dwLevel)
    {
        case URLTEMPLATE_LOW:
            return 3;
        case URLTEMPLATE_MEDLOW:
            return 2;
        case URLTEMPLATE_MEDIUM:
            return 1;
        case URLTEMPLATE_HIGH:
            return 0;        
        case URLTEMPLATE_CUSTOM:
            return -1;            
        default:
            return -2;
    }
}

DWORD SliderPosToSecLevel(int iPos)
{
    switch(iPos)
    {
        case 3:
            return URLTEMPLATE_LOW;
        case 2:
            return URLTEMPLATE_MEDLOW;
        case 1:
            return URLTEMPLATE_MEDIUM;
        case 0:
            return URLTEMPLATE_HIGH;
        default:
            return URLTEMPLATE_CUSTOM;
    }
}

int ZoneIndexToGuiIndex(DWORD dwZoneIndex)
// Product testing asked for the zones in a specific order in the list box;
// This function returns the desired gui position for a given zone
// Unrecognized zones are added to the front
{
    int iGuiIndex = -1;
    switch(dwZoneIndex)
    {
        // Intranet: 2nd spot
        case 1:
            iGuiIndex = 1;
            break;

        // Internet: 1st spot
        case 3:
            iGuiIndex = 0;
            break;

        // Trusted Sites: 3rd Spot
        case 2:
            iGuiIndex = 2;
            break;

        // Restricted Sites: 4th Spot
        case 4:
            iGuiIndex = 3;
            break;

        // unknown zone
        default:
            iGuiIndex = -1;   
            break;
    }


    return iGuiIndex;
}



// Initialize the global variables (to be destroyed at WM_DESTROY)
// pSec, Urlmon, pSec->pInternetZoneManager, pSec->hIml
// and set up the proper relationships among them
BOOL SecurityInitGlobals(LPSECURITYPAGE * ppSec, HWND hDlg, SECURITYINITFLAGS * psif)
{
    DWORD cxIcon;
    DWORD cyIcon;

    LPSECURITYPAGE pSec = NULL;

    *ppSec = (LPSECURITYPAGE)LocalAlloc(LPTR, sizeof(SECURITYPAGE));
    pSec = *ppSec;
    if (!pSec)
    {
        return FALSE;   // no memory?
    }

    // make sure Urlmon stays around until we're done with it.
    pSec->hinstUrlmon = LoadLibrary(TEXT("URLMON.DLL"));
    if(pSec->hinstUrlmon == NULL)
    {
        return FALSE;  // no urlmon?
    }

    // Get the zone manager
    if (FAILED(CoInternetCreateZoneManager(NULL, &(pSec->pInternetZoneManager),0)))
    {
        return FALSE;  // no zone manager?
    }

    // get our zones hwnd
    pSec->hwndZones = GetDlgItem(hDlg, IDC_LIST_ZONE);
    if(! pSec->hwndZones)
    {
        ASSERT(FALSE);
        return FALSE;  // no list box?
    }

    // Get the internet secrity manager (for telling if a zone is empty, 
    // and deciphering the current URL
    if(FAILED(CoInternetCreateSecurityManager(NULL, &(pSec->pInternetSecurityManager), 0)))
        pSec->pInternetSecurityManager = NULL;

    // tell dialog where to get info
    SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)pSec);

    // save the handle to the page
    pSec->hDlg = hDlg;
    pSec->fPendingChange = FALSE;

    // set dialog options: force ui and disable add sites
    if(psif)
    {
        pSec->fForceUI = psif->fForceUI;
        pSec->fDisableAddSites = psif->fDisableAddSites;
    }
    
    // create an imagelist for the ListBox            
    cxIcon = GetSystemMetrics(SM_CXICON);
    cyIcon = GetSystemMetrics(SM_CYICON);
#ifndef UNIX
    UINT flags = ILC_COLOR32|ILC_MASK;
    
    if(IS_WINDOW_RTL_MIRRORED(hDlg))
    {
        flags |= ILC_MIRROR;
    }
    pSec->himl = ImageList_Create(cxIcon, cyIcon, flags, pSec->dwZoneCount, 0);
#else
    pSec->himl = ImageList_Create(cxIcon, cyIcon, ILC_COLOR|ILC_MASK, pSec->dwZoneCount, 0);
#endif
    if(! pSec->himl)
    {
        return FALSE;  // Image list not created
    }
    SendMessage(pSec->hwndZones, LVM_SETIMAGELIST, (WPARAM)LVSIL_NORMAL, (LPARAM)pSec->himl);

    return TRUE;    
}

// Set up the variables in pSec about whether the zone settings can be editted
void SecuritySetEdit(LPSECURITYPAGE pSec)
{
    // if these calls fail then we'll use the default of zero which means no lockout
    DWORD cb;
    

    cb = SIZEOF(pSec->fNoEdit);  
    SHGetValue(HKEY_LOCAL_MACHINE, REGSTR_PATH_SECURITY_LOCKOUT, REGSTR_VAL_OPTIONS_EDIT, 
                NULL, &(pSec->fNoEdit), &cb);

    // also allow g_restrict to restrict changing settings
    pSec->fNoEdit += g_restrict.fSecChangeSettings;
    
    SHGetValue(HKEY_LOCAL_MACHINE, REGSTR_PATH_SECURITY_LOCKOUT, REGSTR_VAL_OPTIONS_EDIT, 
                NULL, &(pSec->fNoAddSites), &cb);

    cb = SIZEOF(pSec->fNoZoneMapEdit);
    SHGetValue(HKEY_LOCAL_MACHINE, REGSTR_PATH_SECURITY_LOCKOUT, REGSTR_VAL_ZONES_MAP_EDIT, 
                NULL, &(pSec->fNoZoneMapEdit), &cb);

    // also allow the g_restrict to restrict edit
    pSec->fNoAddSites += g_restrict.fSecAddSites;
}


// Fill a zone with information from the zone manager and add it to the
// ordered list going to the listbox
// REturn values:
//  S_OK indicates success
//  S_FALSE indicates a good state, but the zone was not added (example: flag ZAFLAGS_NO_UI)
//  E_OUTOFMEMORY
//  E_FAIL - other failure
HRESULT SecurityInitZone(DWORD dwIndex, LPSECURITYPAGE pSec, DWORD dwZoneEnumerator, 
                         LV_ITEM * plviZones, BOOL * pfSpotTaken)
{
        DWORD                   dwZone;
        ZONEATTRIBUTES          za = {0};
        HICON                   hiconSmall = NULL;
        HICON                   hiconLarge = NULL;
        LPSECURITYZONESETTINGS  pszs;
        WORD                    iIcon=0;
        LPWSTR                  psz;
        TCHAR                   szIconPath[MAX_PATH];
        int                     iSpot;
        LV_ITEM *               plvItem;
        HRESULT                 hr = 0;



        // get the zone attributes for this zone
        za.cbSize = sizeof(ZONEATTRIBUTES);
        pSec->pInternetZoneManager->GetZoneAt(dwZoneEnumerator, dwIndex, &dwZone);
        hr = pSec->pInternetZoneManager->GetZoneAttributes(dwZone, &za);
        if(FAILED(hr))
        {
            return S_FALSE;
        }

        // if no ui, then ignore
        if ((za.dwFlags & ZAFLAGS_NO_UI) && !pSec->fForceUI)
        {
            return S_FALSE;
        }



        // create a structure for zone settings
        pszs = (LPSECURITYZONESETTINGS)LocalAlloc(LPTR, sizeof(*pszs));
        if (!pszs)
        {
            return E_OUTOFMEMORY;
        }



        // store settings for later use
        pszs->dwFlags       = za.dwFlags;
        pszs->dwZoneIndex   = dwZone;
        pszs->dwSecLevel    = za.dwTemplateCurrentLevel;    
        pszs->dwMinSecLevel = za.dwTemplateMinLevel;
        pszs->dwRecSecLevel = za.dwTemplateRecommended;                 
        StrCpyN(pszs->szDescription, za.szDescription, ARRAYSIZE(pszs->szDescription));
        StrCpyN(pszs->szDisplayName, za.szDisplayName, ARRAYSIZE(pszs->szDisplayName));
        // load the icon                
        psz = za.szIconPath;
        if (*psz)
        {
            // search for the '#'
            while ((psz[0] != WIDETEXT('#')) && (psz[0] != WIDETEXT('\0')))
                psz++;
            
            // if we found it, then we have the foo.dll#00001200 format
            if (psz[0] == WIDETEXT('#'))
            {
                psz[0] = WIDETEXT('\0');
                StrCpyN(szIconPath, za.szIconPath, ARRAYSIZE(szIconPath));
                iIcon = (WORD)StrToIntW(psz+1);
                CHAR szPath[MAX_PATH];
                SHUnicodeToAnsi(szIconPath, szPath, ARRAYSIZE(szPath));
                ExtractIconExA(szPath,(UINT)(-1*iIcon), &hiconLarge, &hiconSmall, 1);
            }
            else
            {
                hiconLarge = (HICON)ExtractAssociatedIcon(ghInstance, szIconPath, (LPWORD)&iIcon);
            }
        }
        // no icons?!  well, just use the generic icon
        if (!hiconSmall && !hiconLarge)
        {
            hiconLarge = LoadIcon(ghInstance, MAKEINTRESOURCE(IDI_ZONE));
            if(! hiconLarge)
            {
                LocalFree((HLOCAL)pszs);
                return S_FALSE;  // no icon found for this zone, not even the generic one
            }
        }
        // we want to save the Large icon if possible for use in the subdialogs
        pszs->hicon = hiconLarge ? hiconLarge : hiconSmall;

        


        // Find the proper index for the zone in the listbox (there is a user-preferred order)
        iSpot = ZoneIndexToGuiIndex(dwIndex);
        if(iSpot == -1)
        {
            // if not a recognized zone, add it to the end of the list
            iSpot = pSec->dwZoneCount - 1;
        }
        // Make sure there are no collisisons
        while(iSpot >= 0 && pfSpotTaken[iSpot] == TRUE)
        {
            iSpot--;
        }
        // Don't go past beginning of array
        if(iSpot < 0)
        {
            // It can be proven that it is impossible to get here, unless there is
            // something wrong with the function ZoneIndexToGuiIndex
            ASSERT(FALSE);
            LocalFree((HLOCAL)pszs);
            if(hiconSmall)
                DestroyIcon(hiconSmall);
            if(hiconLarge)
                DestroyIcon(hiconLarge);
            return E_FAIL;
        }
        plvItem = &(plviZones[iSpot]);
        pfSpotTaken[iSpot] = TRUE;


        // init the List Box item and save it for later addition
        plvItem->mask           = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
        plvItem->iItem          = iSpot;
        plvItem->iSubItem       = 0;
        // large icons prefered for the icon view (if switch back to report view, prefer small icons)
        plvItem->iImage         = ImageList_AddIcon(pSec->himl, hiconLarge ? hiconLarge : hiconSmall);

        plvItem->pszText        = new TCHAR[MAX_PATH];
        if(! plvItem->pszText)
        {
            LocalFree((HLOCAL)pszs);
            if(hiconSmall)
                DestroyIcon(hiconSmall);   
            if(hiconLarge)
                DestroyIcon(hiconLarge);
            return E_OUTOFMEMORY;
        }

        MLLoadString( IDS_ZONENAME_LOCAL + dwIndex, plvItem->pszText, MAX_PATH);

        plvItem->lParam         = (LPARAM)pszs;       // save the zone settings here

        

        // if we created a small icon, destroy it, since the system does not save the handle
        // when it is added to the imagelist (see ImageList_AddIcon in VC help)
        // Keep it around if we had to use it in place of the large icon
        if (hiconSmall && hiconLarge)
            DestroyIcon(hiconSmall);   

        return S_OK;
}

// Find the current zone from, in order of preference,
// Current URL
// Parameter passed in through dwZone
// Default of internet
void SecurityFindCurrentZone(LPSECURITYPAGE pSec, SECURITYINITFLAGS * psif)
{
    INT_PTR iItem;
    DWORD dwZone=0;
    HRESULT hr = E_FAIL;

    // Check for zone selection in psif
    if(psif)
    {
        dwZone = psif->dwZone;
        hr = S_OK;
    }

    // check for current url, and if found, make it's zone the current (overwriting any request from
    // psif)
    if (g_szCurrentURL[0] && (pSec->pInternetSecurityManager != NULL))
    {
        LPWSTR pwsz;

#ifndef UNICODE
        WCHAR wszCurrentURL[MAX_URL_STRING];
        MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, g_szCurrentURL, -1, wszCurrentURL, ARRAYSIZE(wszCurrentURL));
        pwsz = wszCurrentURL;
#else
        pwsz = g_szCurrentURL;
#endif
        hr = pSec->pInternetSecurityManager->MapUrlToZone(pwsz, (LPDWORD)&dwZone, 0);        
    }
    

    // If there is an active zone, then dwZone now holds the zone's identifier
    // if there is no active zone, check to see if there was a zone requested in dwZone
    iItem = -1;
    if (SUCCEEDED(hr)) // then we have a zone to display
    {
        ZONEATTRIBUTES za = {0};
        LPTSTR pszText;
        LV_FINDINFO lvfiName;
       
        za.cbSize = (ULONG) sizeof(ZONEATTRIBUTES);
        if(pSec->pInternetZoneManager->GetZoneAttributes(dwZone, &za) != E_FAIL)
        {
#ifdef UNICODE    
            pszText        = za.szDisplayName;
#else    
            CHAR szDisplayName[MAX_ZONE_PATH];
            WideCharToMultiByte(CP_ACP, 0, za.szDisplayName, -1, szDisplayName, ARRAYSIZE(szDisplayName), NULL, NULL);
            pszText        = szDisplayName;
#endif // UNICODE

            // Create a find info structure to find the index of the Zone
            lvfiName.flags = LVFI_STRING;
            lvfiName.psz = pszText;
            iItem = SendMessage(pSec->hwndZones, LVM_FINDITEM, (WPARAM)-1, (LPARAM)&lvfiName);
        }
    }

    if (iItem < 0)
    {
        iItem = 0;
        // 0 is the the index (in the listbox) of the "Internet" zone, which we want to come up by default
    }
    // Sundown: typecast OK since zone values restricted
    pSec->iZoneSel = (int) iItem;
}

// To make the slider control accessbile we have to subclass it and over-ride 
// the accessiblity object 

void SecurityInitSlider(LPSECURITYPAGE pSec)
{
    HWND hwndSlider = GetDlgItem(pSec->hDlg, IDC_SLIDER);
    ASSERT(hwndSlider != NULL);

    // Sub-class the control
    BOOL fSucceeded = SetWindowSubclass(hwndSlider, SliderSubWndProc, 0, NULL);

    // Shouldn't fail normally. If we fail we will just fall through and use the
    // base slider control.
    ASSERT(fSucceeded);

    // Initialize the slider control (set number of levels, and frequency one tick per level)
    SendDlgItemMessage(pSec->hDlg, IDC_SLIDER, TBM_SETRANGE, (WPARAM) (BOOL) FALSE, (LPARAM) MAKELONG(0, NUM_TEMPLATE_LEVELS - 1));
    SendDlgItemMessage(pSec->hDlg, IDC_SLIDER, TBM_SETTICFREQ, (WPARAM) 1, (LPARAM) 0);
}
                    
void SecurityInitControls(LPSECURITYPAGE pSec)
{
    LV_COLUMN lvCasey;
    LV_ITEM lvItem;

    // select the item in the listbox
    lvItem.mask = LVIF_STATE;
    lvItem.stateMask = LVIS_SELECTED;
    lvItem.state = LVIS_SELECTED;
    SendMessage(pSec->hwndZones, LVM_SETITEMSTATE, (WPARAM)pSec->iZoneSel, (LPARAM)&lvItem);
    


    // get the zone settings for the selected item
    lvItem.mask  = LVIF_PARAM;
    lvItem.iItem = pSec->iZoneSel;
    lvItem.iSubItem = 0;
    SendMessage(pSec->hwndZones, LVM_GETITEM, (WPARAM)0, (LPARAM)&lvItem);
    pSec->pszs = (LPSECURITYZONESETTINGS)lvItem.lParam;


    // Initialize the local strings to carry the Level Descriptions
    MLLoadString(IDS_TEMPLATE_DESC_HI, LEVEL_DESCRIPTION0, ARRAYSIZE(LEVEL_DESCRIPTION0));
    MLLoadString(IDS_TEMPLATE_DESC_MED, LEVEL_DESCRIPTION1, ARRAYSIZE(LEVEL_DESCRIPTION1));
    MLLoadString(IDS_TEMPLATE_DESC_MEDLOW, LEVEL_DESCRIPTION2, ARRAYSIZE(LEVEL_DESCRIPTION2));
    MLLoadString(IDS_TEMPLATE_DESC_LOW, LEVEL_DESCRIPTION3, ARRAYSIZE(LEVEL_DESCRIPTION3));
    MLLoadString(IDS_TEMPLATE_DESC_CUSTOM, CUSTOM_DESCRIPTION, ARRAYSIZE(CUSTOM_DESCRIPTION));

    MLLoadString(IDS_TEMPLATE_NAME_HI, LEVEL_NAME0, ARRAYSIZE(LEVEL_NAME0));
    MLLoadString(IDS_TEMPLATE_NAME_MED, LEVEL_NAME1, ARRAYSIZE(LEVEL_NAME1));
    MLLoadString(IDS_TEMPLATE_NAME_MEDLOW, LEVEL_NAME2, ARRAYSIZE(LEVEL_NAME2));
    MLLoadString(IDS_TEMPLATE_NAME_LOW, LEVEL_NAME3, ARRAYSIZE(LEVEL_NAME3));
    MLLoadString(IDS_TEMPLATE_NAME_CUSTOM, CUSTOM_NAME, ARRAYSIZE(CUSTOM_NAME));

    // Initialize text boxes and icons for the current zone
    WCHAR wszBuffer[ MAX_PATH*2];
    MLLoadString( IDS_ZONEDESC_LOCAL + pSec->pszs->dwZoneIndex, wszBuffer, ARRAYSIZE(wszBuffer));
    SetDlgItemText(pSec->hDlg, IDC_ZONE_DESCRIPTION, wszBuffer);
    MLLoadString( IDS_ZONENAME_LOCAL + pSec->pszs->dwZoneIndex, wszBuffer, ARRAYSIZE(wszBuffer));
    SetDlgItemText(pSec->hDlg, IDC_ZONELABEL, wszBuffer);
    SendDlgItemMessage(pSec->hDlg, IDC_ZONE_ICON, STM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)pSec->pszs->hicon);

    // Initialize the slider control
    SecurityInitSlider(pSec);

    // Initialize the list view (add column 0 for icon and text, and autosize it)
    lvCasey.mask = 0;
    SendDlgItemMessage(pSec->hDlg, IDC_LIST_ZONE, LVM_INSERTCOLUMN, (WPARAM) 0, (LPARAM) &lvCasey);
    SendDlgItemMessage(pSec->hDlg, IDC_LIST_ZONE, LVM_SETCOLUMNWIDTH, (WPARAM) 0, (LPARAM) MAKELPARAM(LVSCW_AUTOSIZE, 0));

    // Set the font of the name to the bold font
    pSec->hfontBolded = NULL;
    HFONT hfontOrig = (HFONT) SendDlgItemMessage(pSec->hDlg, IDC_STATIC_EMPTY, WM_GETFONT, (WPARAM) 0, (LPARAM) 0);
    if(hfontOrig == NULL)
        hfontOrig = (HFONT) GetStockObject(SYSTEM_FONT);

    // set the zone name and level font to bolded
    if(hfontOrig)
    {
        LOGFONT lfData;
        if(GetObject(hfontOrig, SIZEOF(lfData), &lfData) != 0)
        {
            // The distance from 400 (normal) to 700 (bold)
            lfData.lfWeight += 300;
            if(lfData.lfWeight > 1000)
                lfData.lfWeight = 1000;
            pSec->hfontBolded = CreateFontIndirect(&lfData);
            if(pSec->hfontBolded)
            {
                // the zone level and zone name text boxes should have the same font, so this is okat
                SendDlgItemMessage(pSec->hDlg, IDC_ZONELABEL, WM_SETFONT, (WPARAM) pSec->hfontBolded, (LPARAM) MAKELPARAM(FALSE, 0));
                SendDlgItemMessage(pSec->hDlg, IDC_LEVEL_NAME, WM_SETFONT, (WPARAM) pSec->hfontBolded, (LPARAM) MAKELPARAM(FALSE, 0));

            }
        }
    }

/*
    {
        // calculate the postions of the static text boxes for the "The current level is:" "<bold>(Level)</bold>" message
        TCHAR * pszText = NULL;
        LONG lLength = 30;
        HDC hdc = NULL;
        SIZE size;
        RECT rect;
        LONG lNameLeftPos = 0;

        // Get the text from the "The current level is" box.
        lLength = SendDlgItemMessage(pSec->hDlg, IDC_SEC_STATIC_CURRENT_LEVEL, WM_GETTEXTLENGTH, 
                                     (WPARAM) 0, (LPARAM) 0);
        pszText = new TCHAR[lLength + 1];
        if(!pszText)
            goto Exit; // E_OUTOFMEMORY
        SendDlgItemMessage(pSec->hDlg, IDC_SEC_STATIC_CURRENT_LEVEL, WM_GETTEXT, (WPARAM) lLength, 
                           (LPARAM) pszText);

        // get the device context
        hdc = GetDC(GetDlgItem(pSec->hDlg, IDC_SEC_STATIC_CURRENT_LEVEL));
        if(! hdc)
            goto Exit;
        // get the length of the text from the device context; assumes the proper font is already in
        if(GetTextExtentPoint32(hdc, pszText, lLength, &size) == 0)
            goto Exit;

        // set the width of the "The current level is" box
        GetClientRect(GetDlgItem(pSec->hDlg, IDC_SEC_STATIC_CURRENT_LEVEL), &rect);
        rect.right = rect.left + size.cx;
        lNameLeftPos = rect.right;
        if(MoveWindow(GetDlgItem(pSec->hDlg, IDC_SEC_STATIC_CURRENT_LEVEL), rect.left, rect.top, 
                      rect.right - rect.left, rect.top - rect.bottom, FALSE) == 0)
            goto Exit;

        // set the x position of the level name box
        GetClientRect(GetDlgItem(pSec->hDlg, IDC_LEVEL_NAME), &rect);
        rect.left = lNameLeftPos;
        if(MoveWindow(GetDlgItem(pSec->hDlg, IDC_LEVEL_NAME), rect.left, 
                      rect.top, rect.right - rect.left, rect.top - rect.bottom, FALSE) == 0)
            goto Exit;

Exit:
        if(hdc)
            ReleaseDC(GetDlgItem(pSec->hDlg, IDC_SEC_STATIC_CURRENT_LEVEL), hdc);
        if(pszText)
            delete pszText;
    }
    */
}


//
// SecurityDlgInit()
//
// Does initalization for Security Dlg.
//
// History:
//
// 6/17/96  t-gpease   remove 'gPrefs', cleaned up code
// 6/20/96  t-gpease   UI changes
// 5/14/97  t-ashlm    UI changes 
//
// 7/02/97  t-mattp    UI changes (slider, listbox)
//
// hDlg is the handle to the SecurityDialog window
// psif holds initialization parameters.  In the case of our entry point
//      from shdocvw (ie, double click browser zone icon, view-internetoptions-security, or right click
//      on desktop icon), it can be NULL

BOOL SecurityDlgInit(HWND hDlg, SECURITYINITFLAGS * psif)
{
    LPSECURITYPAGE  pSec = NULL;
    UINT iIndex = 0;
    HRESULT hr = 0;
    DWORD dwZoneEnumerator;
    
    // Initialize globals variables (to be destroyed at WM_DESTROY)
    if(SecurityInitGlobals(&pSec, hDlg, psif) == FALSE)
    {
        EndDialog(hDlg, 0);
        return FALSE;  // Initialization failed
    }

    // Get a (local) enumerator for the zones
    if (FAILED(pSec->pInternetZoneManager->
                     CreateZoneEnumerator(&dwZoneEnumerator, &(pSec->dwZoneCount), 0)))
    {
        EndDialog(hDlg, 0);
        return FALSE;  // no zone enumerator?
    }


    // Set up the variables in pSec about whether the zone settings can be editted
    SecuritySetEdit(pSec);

         
    // Add the Listbox items for the zones


    // The zones have to be added in a particular order
    // Array used to order zones for adding
    LV_ITEM * plviZones = new LV_ITEM[pSec->dwZoneCount];
    BOOL * pfSpotTaken = new BOOL[pSec->dwZoneCount];
    for(iIndex =0; iIndex < pSec->dwZoneCount; iIndex++)
        pfSpotTaken[iIndex] = FALSE;

    // propogate zone dropdown
    for (DWORD dwIndex=0; dwIndex < pSec->dwZoneCount; dwIndex++)
    {
        if(FAILED(SecurityInitZone(dwIndex, pSec, dwZoneEnumerator, plviZones, pfSpotTaken)))
        {
            // Delete all memory allocated for any previous zones (which have not yet been added to
            // the listbox)
            for(iIndex = 0; iIndex < pSec->dwZoneCount; iIndex++)
            {
                if(pfSpotTaken[iIndex] && (LPSECURITYZONESETTINGS) (plviZones[iIndex].lParam) != NULL)
                {
                    LocalFree((LPSECURITYZONESETTINGS) (plviZones[iIndex].lParam));
                    plviZones[iIndex].lParam = NULL;
                    if(plviZones[iIndex].pszText)
                        delete [] plviZones[iIndex].pszText;
                }
            }
            delete [] plviZones;
            delete [] pfSpotTaken;
            pSec->pInternetZoneManager->DestroyZoneEnumerator(dwZoneEnumerator);
            EndDialog(hDlg, 0);
            return FALSE;
        }
    }
    pSec->pInternetZoneManager->DestroyZoneEnumerator(dwZoneEnumerator);


    // Add all of the arrayed listitems to the listbox
    for(iIndex = 0; iIndex < pSec->dwZoneCount; iIndex++)
    {
        if(pfSpotTaken[iIndex])
        {
            SendMessage(pSec->hwndZones, LVM_INSERTITEM, (WPARAM)0, (LPARAM)&(plviZones[iIndex]));
            delete [] plviZones[iIndex].pszText;
        }
    }
    delete [] plviZones;
    delete [] pfSpotTaken;



    SecurityFindCurrentZone(pSec, psif);
    SecurityInitControls(pSec);
    SecurityEnableControls(pSec, FALSE);
    return TRUE;
}

void SecurityChanged()
{
    TCHAR szClassName[32];
    HWND hwnd = GetTopWindow(GetDesktopWindow());

    //
    // FEATURE: These should be gotten from some place that is public
    //         to both MSHTML and INETCPL.
    //
    while (hwnd) {
        GetClassName(hwnd, szClassName, ARRAYSIZE(szClassName));

        // notify all "browser" windows that security has changed            
        if (!StrCmpI(szClassName, TEXT("ExploreWClass"))            ||
            !StrCmpI(szClassName, TEXT("IEFrame"))                  ||
            !StrCmpI(szClassName, TEXT("CabinetWClass")))
        {
            // yes...  post it a message..
            PostMessage(hwnd, CWM_GLOBALSTATECHANGE, CWMF_SECURITY, 0L );
        }

        hwnd = GetNextWindow(hwnd, GW_HWNDNEXT);
    }
}

int SecurityWarning(LPSECURITYPAGE pSec)
{
    TCHAR szWarning[64];

    TCHAR szBuf[512];
    TCHAR szMessage[512];
    TCHAR szLevel[64];

    // Load "Warning!"
    MLLoadShellLangString(IDS_WARNING, szWarning, ARRAYSIZE(szWarning));

    // Load "It is not recommended...."
    MLLoadShellLangString(IDS_SECURITY_WARNING, szBuf, ARRAYSIZE(szBuf));

    // Load level: "High, Medium, Medium Low, Low"
    if (pSec->pszs->dwMinSecLevel == URLTEMPLATE_HIGH)
        MLLoadShellLangString(IDS_TEMPLATE_NAME_HI, szLevel, ARRAYSIZE(szLevel));
    else if (pSec->pszs->dwMinSecLevel == URLTEMPLATE_MEDIUM)
        MLLoadShellLangString(IDS_TEMPLATE_NAME_MED, szLevel, ARRAYSIZE(szLevel));
    else if (pSec->pszs->dwMinSecLevel == URLTEMPLATE_MEDLOW)
        MLLoadShellLangString(IDS_TEMPLATE_NAME_MEDLOW, szLevel, ARRAYSIZE(szLevel));
    else
        MLLoadShellLangString(IDS_TEMPLATE_NAME_LOW, szLevel, ARRAYSIZE(szLevel));

    wnsprintf(szMessage, ARRAYSIZE(szMessage), szBuf, szLevel);

    return MessageBox(pSec->hDlg,szMessage,szWarning, MB_ICONWARNING | MB_YESNO | MB_DEFBUTTON2);
}

int RegWriteWarning(HWND hParent)
{
    TCHAR szWarning[64];
    TCHAR szWriteWarning[128];

    // load "Warning!"
    MLLoadShellLangString(IDS_WARNING, szWarning, ARRAYSIZE(szWarning));
    // Load "You are about to write..."
    MLLoadShellLangString(IDS_WRITE_WARNING, szWriteWarning, ARRAYSIZE(szWriteWarning));

    return MessageBox(hParent,szWriteWarning, szWarning, MB_ICONWARNING | MB_YESNO | MB_DEFBUTTON2);
}


BOOL SecurityEnableControls(LPSECURITYPAGE pSec, BOOL fSetFocus)
// Duties:
// Make the controls (slider, en/disabled buttons) match the data for the current zone
// Make the views (Level description text) match the data for the current zone
// Set focus (to slider, if enabled, else custom settings button, if enabled, else 
//     listbox) if fSetFocus is TRUE
// Note: the zone descriptions are not set here; those are handled by the code responsible
//       for changing zones
{
    int iLevel = -1;


    if (pSec && pSec->pszs)
    {
        HWND hwndSlider = GetDlgItem(pSec->hDlg, IDC_SLIDER);
        
        iLevel = SecLevelToSliderPos(pSec->pszs->dwSecLevel);
        ASSERT(iLevel > -2);

        // Set the level of the slider to the setting for the current zone
        // Show or hide the slider for preset levels/custom
        // Set the level description text
        if(iLevel >= 0)
        {
            SendMessage(hwndSlider, TBM_SETPOS, (WPARAM) (BOOL) TRUE, (LPARAM) (LONG) iLevel);
            // Make sure the slider is visible
            ShowWindow(hwndSlider, SW_SHOW);
            ShowWindow(GetDlgItem(pSec->hDlg, IDC_STATIC_SLIDERMOVETEXT), SW_SHOW);
            SetDlgItemText(pSec->hDlg, IDC_LEVEL_DESCRIPTION, LEVEL_DESCRIPTION[iLevel]);         
            SetDlgItemText(pSec->hDlg, IDC_LEVEL_NAME, LEVEL_NAME[iLevel]);
        }
        else
        {
            // Hide the slider for custom
            ShowWindow(hwndSlider, SW_HIDE);
            ShowWindow(GetDlgItem(pSec->hDlg, IDC_STATIC_SLIDERMOVETEXT), SW_HIDE);
            SetDlgItemText(pSec->hDlg, IDC_LEVEL_DESCRIPTION, CUSTOM_DESCRIPTION);
            SetDlgItemText(pSec->hDlg, IDC_LEVEL_NAME, CUSTOM_NAME);
        }

        // If the zone is empty, show the "zone is empty" string
        // Default is to not show the sting (if something goes wrong)
        // Empty zone not possible for internet, intranet, or local zones
        if((pSec->pszs->dwZoneIndex != URLZONE_INTRANET && 
            pSec->pszs->dwZoneIndex != URLZONE_INTERNET) &&
            pSec->pszs->dwZoneIndex != URLZONE_LOCAL_MACHINE &&
            (pSec->pInternetSecurityManager != NULL))
        {
            IEnumString * piesZones = NULL;
            LPOLESTR ppszDummy[1];
            pSec->pInternetSecurityManager->GetZoneMappings(pSec->pszs->dwZoneIndex, &piesZones, 0);

            // If enumerator can not get 1 item, zone is empty (not valid for internet and intranet)
            if(piesZones && (piesZones->Next(1, ppszDummy, NULL) == S_FALSE))
            {
                ShowWindow(GetDlgItem(pSec->hDlg, IDC_STATIC_EMPTY), SW_SHOW);
            }
            else
            {
                ShowWindow(GetDlgItem(pSec->hDlg, IDC_STATIC_EMPTY), SW_HIDE);
            }
            if(piesZones)
                piesZones->Release();
        }
        else
        {
            ShowWindow(GetDlgItem(pSec->hDlg, IDC_STATIC_EMPTY), SW_HIDE);
        }

        // If we were told to set focus then move focus to the slider.
        if (fSetFocus)
        {
            if(!pSec->fNoEdit)
            {
               if(iLevel >= 0)
                    SetFocus(hwndSlider);
               else if(pSec->pszs->dwFlags & ZAFLAGS_CUSTOM_EDIT)
                    SetFocus(GetDlgItem(pSec->hDlg, IDC_BUTTON_SETTINGS));
               else
                 SetFocus(GetDlgItem(pSec->hDlg, IDC_LIST_ZONE));
            }
            else // No focus is allowed, set focus to the list box
            {
                SetFocus(GetDlgItem(pSec->hDlg, IDC_LIST_ZONE));
            }

        }
        EnableWindow(hwndSlider, (iLevel >= 0) && !pSec->fNoEdit);
        EnableWindow(GetDlgItem(pSec->hDlg, IDC_ZONE_RESET), 
                     !pSec->fNoEdit && (pSec->pszs->dwSecLevel != pSec->pszs->dwRecSecLevel));
        EnableWindow(GetDlgItem(pSec->hDlg, IDC_BUTTON_SETTINGS), 
                     (pSec->pszs->dwFlags & ZAFLAGS_CUSTOM_EDIT) && !pSec->fNoEdit);
        EnableWindow(GetDlgItem(pSec->hDlg, IDC_BUTTON_ADD_SITES), 
                     (pSec->pszs->dwFlags & ZAFLAGS_ADD_SITES) && !pSec->fDisableAddSites);

        return TRUE;
    }

    return FALSE;
}

void SecuritySetLevel(DWORD dwLevel, LPSECURITYPAGE pSec)
{
    // All calls to this function are requests to change the security
    // level for the current zone
    // dwLevel = requested level template (URLTEMPLATE_???)
    int iPos = SecLevelToSliderPos(dwLevel);
    ASSERT(iPos != -2);
    BOOL bCanceled = FALSE;

    // Do nothing if the requested level is equal to the current level 
    if(dwLevel != pSec->pszs->dwSecLevel)
    {
        // Pop up warning box if under recommended min level and lowering security (custom N/A)
        if((pSec->pszs->dwMinSecLevel > dwLevel) && (pSec->pszs->dwSecLevel > dwLevel)
            && (dwLevel != URLTEMPLATE_CUSTOM))
        {
            if(SecurityWarning(pSec) == IDNO)
            {
                bCanceled = TRUE;
            }
        }                
        if(! bCanceled)
        {
            // Set the level
            pSec->pszs->dwPrevSecLevel = pSec->pszs->dwSecLevel;
            pSec->pszs->dwSecLevel = dwLevel;
            ENABLEAPPLY(pSec->hDlg);

            //Tell apply and ok that settings have been changed
            pSec->fChanged = TRUE;
        }
        // Sync the controls to the new level (or back to the old if cancelled)
        SecurityEnableControls(pSec, TRUE);
    }
    // Record that the change request has been handled
    pSec->fPendingChange = FALSE;
}


//
// SecurityDlgApplyNow()
//
// Retrieves the user's choices in dlg ctls,
//    and saves them through SecurityManager interfaces
// If bSaveAll is true, the data for all zones is saved,
// if false, only the current
// Return value is whether the changes were okayed 
//
BOOL SecurityDlgApplyNow(LPSECURITYPAGE pSec, BOOL bSaveAll)
{
    if (pSec->fChanged)
    {
        for (int iIndex = (int)SendMessage(pSec->hwndZones, LVM_GETITEMCOUNT, 0, 0) - 1;
             iIndex >= 0; iIndex--)
        {
            if(!((bSaveAll) || (iIndex == pSec->iZoneSel)))
                continue;
            LV_ITEM lvItem = {0};
            ZONEATTRIBUTES za = {0};
            LPSECURITYZONESETTINGS pszs;
            
            // get the item settings
            lvItem.mask  = LVIF_PARAM;
            lvItem.iItem = iIndex;
            lvItem.iSubItem = 0;
            if(SendMessage(pSec->hwndZones, LVM_GETITEM, (WPARAM)0, (LPARAM)&lvItem))
            {
                pszs = (LPSECURITYZONESETTINGS)lvItem.lParam;

                za.cbSize = sizeof(ZONEATTRIBUTES);
                pSec->pInternetZoneManager->GetZoneAttributes(pszs->dwZoneIndex, &za);
                za.dwTemplateCurrentLevel = pszs->dwSecLevel;
                pSec->pInternetZoneManager->SetZoneAttributes(pszs->dwZoneIndex, &za);
                // Custom settings are saved on exit from the Custom Settings window
            }
        }
        UpdateAllWindows();
        SecurityChanged();
        if (bSaveAll)
        {
            // if bSaveAll is false, that means we're saving the info for one zone, but not
            // the others. This happens when you have custom settings for a particular zone
            // However, other zones may have been changed to only one of the standard settings
            // We need to ensure that those settings also get saved when the user clicks OK/Apply.
            pSec->fChanged = FALSE;
        }
    }
    return TRUE;
}


//
// SecurityOnCommand()
//
// Handles Security Dialog's window messages
//
// History:
//
// 6/17/96  t-gpease   created
// 5/14/97  t-ashlm    ui changes
//
void SecurityOnCommand(LPSECURITYPAGE pSec, UINT id, UINT nCmd)
{

    switch (id)
    {
        case IDC_BUTTON_ADD_SITES:
        {
            if (pSec->pszs->dwZoneIndex == URLZONE_INTRANET)
                DialogBoxParam(MLGetHinst(), MAKEINTRESOURCE(IDD_SECURITY_INTRANET), pSec->hDlg,
                               SecurityAddSitesIntranetDlgProc, (LPARAM)pSec);
            else
                DialogBoxParam(MLGetHinst(), MAKEINTRESOURCE(IDD_SECURITY_ADD_SITES), pSec->hDlg,
                               SecurityAddSitesDlgProc, (LPARAM)pSec);
                               
            // Resynch controls (in case the "zone is empty" message needs to be updated)
            SecurityEnableControls(pSec, FALSE);
        }   
        break;

        case IDC_BUTTON_SETTINGS:
        {
            // Note: messages to change the level from preset to custom as a result of this call
            //       are sent by the CustomSettings dialog
            DialogBoxParam(MLGetHinst(), MAKEINTRESOURCE(IDD_SECURITY_CUSTOM_SETTINGS), pSec->hDlg,
                           SecurityCustomSettingsDlgProc, (LPARAM)pSec);
            break;
        }
        case IDC_ZONE_RESET:
            if(!pSec->fPendingChange && pSec->pszs->dwSecLevel != pSec->pszs->dwRecSecLevel)
            {
                pSec->fPendingChange = TRUE;
                PostMessage(pSec->hDlg, WM_APP, (WPARAM) 0, (LPARAM) pSec->pszs->dwRecSecLevel);
            }
            break;
            
        case IDOK:
            SecurityDlgApplyNow(pSec, TRUE);
            EndDialog(pSec->hDlg, IDOK);
            break;
            
        case IDCANCEL:
            EndDialog(pSec->hDlg, IDCANCEL);
            break;
            
        case IDC_SLIDER:
            {
                // Get the current slider position
                // Sundown: forced typecast to int, slider positions are restricted
                int iPos = (int) SendDlgItemMessage(pSec->hDlg, IDC_SLIDER, TBM_GETPOS, (WPARAM) 0, (LPARAM) 0);
                if(nCmd == TB_THUMBTRACK)
                {
                    // on Mouse Move, change the level description only
                    SetDlgItemText(pSec->hDlg, IDC_LEVEL_DESCRIPTION, LEVEL_DESCRIPTION[iPos]);
                    SetDlgItemText(pSec->hDlg, IDC_LEVEL_NAME, LEVEL_NAME[iPos]);
                }
                else
                {
                    // Request that the current zone's security level be set to the corresponding level
                    DWORD_PTR dwLevel = SliderPosToSecLevel(iPos);
                    if(! pSec->fPendingChange)
                    {
                        pSec->fPendingChange = TRUE;
                        PostMessage(pSec->hDlg, WM_APP, (WPARAM) 0, (LPARAM) dwLevel);
                    }
                }
            }
            break;
            
        case IDC_LIST_ZONE:
        {
            // Sundown: coercion to int-- selection is range-restricted
            int iNewSelection = (int) SendMessage(pSec->hwndZones, LVM_GETNEXTITEM, (WPARAM)-1, 
                                                  MAKELPARAM(LVNI_SELECTED, 0));

            if ((iNewSelection != pSec->iZoneSel) && (iNewSelection != -1))
            {
                LV_ITEM lvItem;

                lvItem.iItem = iNewSelection;
                lvItem.iSubItem = 0;
                lvItem.mask  = LVIF_PARAM;                                            
                SendMessage(pSec->hwndZones, LVM_GETITEM, (WPARAM)0, (LPARAM)&lvItem);
                pSec->pszs = (LPSECURITYZONESETTINGS)lvItem.lParam;
                pSec->iZoneSel = iNewSelection;

                WCHAR wszBuffer[ MAX_PATH*2];
                MLLoadString( IDS_ZONEDESC_LOCAL + pSec->pszs->dwZoneIndex, wszBuffer, ARRAYSIZE(wszBuffer));
                SetDlgItemText(pSec->hDlg, IDC_ZONE_DESCRIPTION, wszBuffer);
                MLLoadString( IDS_ZONENAME_LOCAL + pSec->pszs->dwZoneIndex, wszBuffer, ARRAYSIZE(wszBuffer));
                SetDlgItemText(pSec->hDlg, IDC_ZONELABEL, wszBuffer);
                SendDlgItemMessage(pSec->hDlg, IDC_ZONE_ICON, STM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)pSec->pszs->hicon);
                SecurityEnableControls(pSec, FALSE);
            }    
            break;
        }
    }   

} // SecurityOnCommand()


//
// SecurityDlgProc()
//
// Handles Security Dialog's window messages
//
// History:
//
// 6/17/96  t-gpease   created
// 5/14/97  t-ashlm    ui changes
//
INT_PTR CALLBACK SecurityDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    LPSECURITYPAGE pSec;

    if (uMsg == WM_INITDIALOG)
    {
        // A hack forced by PropertyPage:
        // PropertyPage creates this dialog in mainwnd.cpp when the dialog is entered from
        // the desktop e's properties, the browser's menu view-internetoptions-security, or
        // right clicking on the browser's zone icon.
        // In the property page case, lParam (our only route to get initialization information
        // in) is a pointer to a PROPERTYSHEETHEADER, more or less, and of entirely no use to us.
        // However, when called from our exported function LaunchSecurityDialogEx, using
        // CreateDialogParamWrapW, we want to pass useful information in.  The only way to make sure 
        // we our dealing with useful information is to make the passed in pointer be to a 
        // structure we know and love, and hence could not possibly be pointed to by PropertyPage.  
        // We use a ThreadLocalStorage object, as our information reference
        SECURITYINITFLAGS * psif = NULL;
        if(g_dwtlsSecInitFlags != (DWORD) -1)
            psif = (SECURITYINITFLAGS *) TlsGetValue(g_dwtlsSecInitFlags);
        if((SECURITYINITFLAGS *) lParam != psif)
            psif = NULL; 
        return SecurityDlgInit(hDlg, psif);
    }

    pSec = (LPSECURITYPAGE)GetWindowLongPtr(hDlg, DWLP_USER);
    if (!pSec)
        return FALSE;
    
    switch (uMsg)
    {
        case WM_COMMAND:
            SecurityOnCommand(pSec, LOWORD(wParam), HIWORD(wParam));
            return TRUE;

        case WM_NOTIFY:
        {
            NMHDR *lpnm = (NMHDR *) lParam;

            ASSERT(lpnm);

            // List Box Messages
            if(lpnm->idFrom == IDC_LIST_ZONE)
            {
                NM_LISTVIEW * lplvnm = (NM_LISTVIEW *) lParam;
                if(lplvnm->hdr.code == LVN_ITEMCHANGED)
                {
                    // If an item's state has changed, and it is now selected
                    if(((lplvnm->uChanged & LVIF_STATE) != 0) && ((lplvnm->uNewState & LVIS_SELECTED) != 0))
                    {
                        SecurityOnCommand(pSec, IDC_LIST_ZONE, LVN_ITEMCHANGED);
                    }                   
                }
            }
            else
            {
                switch (lpnm->code)
                {
                    case PSN_QUERYCANCEL:
                    case PSN_KILLACTIVE:
                    case PSN_RESET:
                        SetWindowLongPtr(pSec->hDlg, DWLP_MSGRESULT, FALSE);
                        return TRUE;

                    case PSN_APPLY:
                        // Hitting the apply button runs this code
                        SecurityDlgApplyNow(pSec, TRUE);
                        break;
                }
            }
        }
        break;

        case WM_HELP:           // F1
            ResWinHelp( (HWND)((LPHELPINFO)lParam)->hItemHandle, IDS_HELPFILE,
                        HELP_WM_HELP, (DWORD_PTR)(LPSTR)mapIDCsToIDHs);
            break;

        case WM_APP:
            // A message needs to be posted, because the set tools sometimes send two messages
            // hence we need delayed action and a pending change boolean
            // lParam is the level to set for this message
            // wParam is not used
            SecuritySetLevel((DWORD) lParam, pSec);
            break;
        case WM_VSCROLL:
            // Slider Messages
            SecurityOnCommand(pSec, IDC_SLIDER, LOWORD(wParam));
            return TRUE;

        case WM_CONTEXTMENU:        // right mouse click
            ResWinHelp( (HWND) wParam, IDS_HELPFILE,
                        HELP_CONTEXTMENU, (DWORD_PTR)(LPSTR)mapIDCsToIDHs);
            break;

        case WM_DESTROY:
            if(! pSec)
                break;

            if(pSec->hwndZones)
            {
                for (int iIndex = (int)SendMessage(pSec->hwndZones, LVM_GETITEMCOUNT, 0, 0) - 1;
                     iIndex >= 0; iIndex--)
                {
                    LV_ITEM lvItem;

                    // get security zone settings object for this item and release it
                    lvItem.mask = LVIF_PARAM;
                    lvItem.iItem = iIndex;
                    lvItem.iSubItem = 0;
                    if (SendMessage(pSec->hwndZones, LVM_GETITEM, (WPARAM)0, (LPARAM)&lvItem) == TRUE)
                    {
                        LPSECURITYZONESETTINGS pszs = (LPSECURITYZONESETTINGS)lvItem.lParam;
                        if (pszs)
                        {
                            if (pszs->hicon)
                                DestroyIcon(pszs->hicon);
                            LocalFree((HLOCAL)pszs);
                            pszs = NULL;
                        }
                    }                 
                }   
            }

            if(pSec->pInternetZoneManager)
                pSec->pInternetZoneManager->Release();

            if(pSec->pInternetSecurityManager)
                pSec->pInternetSecurityManager->Release();

            if(pSec->himl)
                ImageList_Destroy(pSec->himl);

            if(pSec->hfontBolded)
                DeleteObject(pSec->hfontBolded);

            // ok, we're done with URLMON
            if(pSec->hinstUrlmon)
                FreeLibrary(pSec->hinstUrlmon);
            
            LocalFree(pSec);
            SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)NULL);
            break;
    }
    return FALSE;
}

// Subclassed window proc for the slider. This is used to take over the
// accessibility wrapper for the class so we can return the right zone
// string ( i.e. High, Medium, Low, etc). Just trap WM_GETOBJECT and pass
// in our override of the accessibility wrapper. 

LRESULT CALLBACK SliderSubWndProc (HWND hwndSlider, UINT uMsg, WPARAM wParam, LPARAM lParam, WPARAM uID, ULONG_PTR dwRefData)
{
    ASSERT(uID == 0);
    ASSERT(dwRefData == 0);

    switch (uMsg)
    {
        case WM_GETOBJECT:
            if ( lParam == OBJID_CLIENT )
            {       
                // At this point we will try to load oleacc and get the functions
                // we need. 
                if (!g_fAttemptedOleAccLoad)
                {
                    g_fAttemptedOleAccLoad = TRUE;

                    ASSERT(s_pfnCreateStdAccessibleProxy == NULL);
                    ASSERT(s_pfnLresultFromObject == NULL);

                    g_hOleAcc = LoadLibrary(TEXT("OLEACC"));
                    if (g_hOleAcc != NULL)
                    {
        #ifdef UNICODE
                        s_pfnCreateStdAccessibleProxy = (PFNCREATESTDACCESSIBLEPROXY)
                                                    GetProcAddress(g_hOleAcc, "CreateStdAccessibleProxyW");
        #else
                        s_pfnCreateStdAccessibleProxy = (PFNCREATESTDACCESSIBLEPROXY)
                                                    GetProcAddress(g_hOleAcc, "CreateStdAccessibleProxyA");
        #endif
                        s_pfnLresultFromObject = (PFNLRESULTFROMOBJECT)
                                                    GetProcAddress(g_hOleAcc, "LresultFromObject");
                    }
                    if (s_pfnLresultFromObject == NULL || s_pfnCreateStdAccessibleProxy == NULL)
                    {
                        // No point holding on to Oleacc since we can't use it.
                        FreeLibrary(g_hOleAcc);
                        g_hOleAcc = NULL;
                        s_pfnLresultFromObject = NULL;
                        s_pfnCreateStdAccessibleProxy = NULL;
                    }
                }

                
                if (g_hOleAcc && s_pfnCreateStdAccessibleProxy && s_pfnLresultFromObject)
                {
                    IAccessible *pAcc = NULL;
                    HRESULT hr;
                
                    // Create default slider proxy.
                    hr = s_pfnCreateStdAccessibleProxy(
                            hwndSlider,
                            TEXT("msctls_trackbar32"),
                            OBJID_CLIENT,
                            IID_IAccessible,
                            (void **)&pAcc
                            );


                    if (SUCCEEDED(hr) && pAcc)
                    {
                        // now wrap it up in our customized wrapper...
                        IAccessible * pWrapAcc = new CSecurityAccessibleWrapper( hwndSlider, pAcc );
                        // Release our ref to proxy (wrapper has its own addref'd ptr)...
                        pAcc->Release();
                    
                        if (pWrapAcc != NULL)
                        {

                            // ...and return the wrapper via LresultFromObject...
                            LRESULT lr = s_pfnLresultFromObject( IID_IAccessible, wParam, pWrapAcc );
                            // Release our interface pointer - OLEACC has its own addref to the object
                            pWrapAcc->Release();

                            // Return the lresult, which 'contains' a reference to our wrapper object.
                            return lr;
                            // All done!
                        }
                    // If it didn't work, fall through to default behavior instead. 
                    }
                }
            }
            break;

        case WM_DESTROY:
            RemoveWindowSubclass(hwndSlider, SliderSubWndProc, uID);
            break;    

    } /* end switch */

    return DefSubclassProc(hwndSlider, uMsg, wParam, lParam);
}

                        
                          




HRESULT _AddSite(LPADDSITESINFO pasi)
{
    HRESULT hr = S_OK;
    LPWSTR psz;

    SendMessage(pasi->hwndAdd, WM_GETTEXT, MAX_ZONE_PATH, (LPARAM)pasi->szWebSite);
#ifndef UNICODE
    WCHAR wszMapping[MAX_ZONE_PATH];
    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pasi->szWebSite, sizeof(pasi->szWebSite),  wszMapping, ARRAYSIZE(wszMapping));
    psz = wszMapping;
#else
    psz = pasi->szWebSite;
#endif

    if (*psz)
    {


        pasi->fRSVOld = pasi->fRequireServerVerification;
        pasi->fRequireServerVerification = IsDlgButtonChecked(pasi->hDlg, IDC_CHECK_REQUIRE_SERVER_VERIFICATION);                 

        // if the state of RequireServerVer has changed, then do a SetZoneAttr so we'll get the correct error codes
        if (pasi->fRSVOld != pasi->fRequireServerVerification)
        {
            ZONEATTRIBUTES za;
            za.cbSize = sizeof(ZONEATTRIBUTES);
            pasi->pSec->pInternetZoneManager->GetZoneAttributes(pasi->pSec->pszs->dwZoneIndex, &za);
            if (pasi->fRequireServerVerification)
                za.dwFlags |= ZAFLAGS_REQUIRE_VERIFICATION;
            else
                za.dwFlags &= ~ZAFLAGS_REQUIRE_VERIFICATION;
            
            pasi->pSec->pInternetZoneManager->SetZoneAttributes(pasi->pSec->pszs->dwZoneIndex, &za);

        }
        
        hr = pasi->pSec->pInternetSecurityManager->SetZoneMapping(pasi->pSec->pszs->dwZoneIndex,
            psz, SZM_CREATE);

        if (FAILED(hr))
        {
            UINT id = IDS_MAPPINGFAIL;
        
            if (hr == URL_E_INVALID_SYNTAX)
            {
                id = IDS_INVALIDURL;
            }
            else if (hr == E_INVALIDARG)
            {
                id = IDS_INVALIDWILDCARD;
            }
            else if (hr == E_ACCESSDENIED)
            {
                id = IDS_HTTPSREQ;
            }
            else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS))
            {
                id = IDS_SITEEXISTS;
            }

            MLShellMessageBox(pasi->hDlg, MAKEINTRESOURCEW(id), NULL, MB_ICONSTOP|MB_OK);
            Edit_SetSel(pasi->hwndAdd, 0, -1);
        }
        else
        {
            SendMessage(pasi->hwndWebSites, LB_ADDSTRING, (WPARAM)0, (LPARAM)pasi->szWebSite);
            SendMessage(pasi->hwndAdd, WM_SETTEXT, (WPARAM)0, (LPARAM)NULL);
            SetFocus(pasi->hwndAdd);
        }
    }
    return hr;
}

INT_PTR CALLBACK SecurityAddSitesDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,LPARAM lParam)
{
    LPADDSITESINFO pasi;

    if (uMsg == WM_INITDIALOG)
    {
        pasi = (LPADDSITESINFO)LocalAlloc(LPTR, sizeof(*pasi));
        if (!pasi)
        {
            EndDialog(hDlg, IDCANCEL);
            return FALSE;
        }

        // tell dialog where to get info
        SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)pasi);

        // save the handle to the page
        pasi->hDlg         = hDlg;
        pasi->pSec         = (LPSECURITYPAGE)lParam;
        pasi->hwndWebSites = GetDlgItem(hDlg, IDC_LIST_WEBSITES);
        pasi->hwndAdd      = GetDlgItem(hDlg, IDC_EDIT_ADD_SITE);

        // cross-lang platform support
        SHSetDefaultDialogFont(hDlg, IDC_EDIT_ADD_SITE);

        // limit the text so it will fit
        SendMessage(pasi->hwndAdd, EM_SETLIMITTEXT, (WPARAM)sizeof(pasi->szWebSite), (LPARAM)0);

        pasi->fRequireServerVerification = pasi->pSec->pszs->dwFlags & ZAFLAGS_REQUIRE_VERIFICATION;
        CheckDlgButton(hDlg, IDC_CHECK_REQUIRE_SERVER_VERIFICATION, pasi->fRequireServerVerification);
        
        // hide the checkbox if it doesn't support server verification
        if (!(pasi->pSec->pszs->dwFlags & ZAFLAGS_SUPPORTS_VERIFICATION))
            ShowWindow(GetDlgItem(hDlg, IDC_CHECK_REQUIRE_SERVER_VERIFICATION), SW_HIDE);

        SendMessage(hDlg, WM_SETTEXT, (WPARAM)0, (LPARAM)pasi->pSec->pszs->szDisplayName);
        SetDlgItemText(hDlg, IDC_ADDSITES_GROUPBOX,(LPTSTR)pasi->pSec->pszs->szDisplayName);
        SendDlgItemMessage(hDlg, IDC_ZONE_ICON, STM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)pasi->pSec->pszs->hicon);
        EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_REMOVE), FALSE);
        
        if (pasi->pSec->pInternetSecurityManager || SUCCEEDED(CoInternetCreateSecurityManager(NULL, &(pasi->pSec->pInternetSecurityManager), 0)))
        {
            IEnumString *pEnum;

            if (SUCCEEDED(pasi->pSec->pInternetSecurityManager->GetZoneMappings(pasi->pSec->pszs->dwZoneIndex, &pEnum, 0)))
            {
                LPOLESTR pszMapping;
#ifndef UNICODE
                CHAR szMapping[MAX_URL_STRING];
#endif
                LPTSTR psz;

                while (pEnum->Next(1, &pszMapping, NULL) == S_OK)
                {
#ifndef UNICODE
                    WideCharToMultiByte(CP_ACP, 0, pszMapping, -1, szMapping, ARRAYSIZE(szMapping), NULL, NULL);
                    psz = szMapping;
#else
                    psz = pszMapping;
#endif // UNICODE                       
                    SendMessage(pasi->hwndWebSites, LB_INSERTSTRING, (WPARAM)-1, (LPARAM)psz);
                    CoTaskMemFree(pszMapping);
                }
                pEnum->Release();
            }
        }
        
        if (pasi->pSec->fNoAddSites || pasi->pSec->fNoZoneMapEdit)
        {
            EnableDlgItem(hDlg, IDC_EDIT_ADD_SITE, FALSE);
            EnableDlgItem(hDlg, IDC_BUTTON_REMOVE, FALSE);            
        }

        if (pasi->pSec->fNoZoneMapEdit)
        {
            EnableDlgItem(hDlg, IDC_CHECK_REQUIRE_SERVER_VERIFICATION, FALSE);
            EnableDlgItem(hDlg, IDS_STATIC_ADDSITE, FALSE);            
        }

        SHAutoComplete(GetDlgItem(hDlg, IDC_EDIT_ADD_SITE), SHACF_DEFAULT);
    }
    
    else
        pasi = (LPADDSITESINFO)GetWindowLongPtr(hDlg, DWLP_USER);

    if (!pasi)
        return FALSE;
    
    switch (uMsg)
    {
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDOK:
                {
                    ZONEATTRIBUTES za;

                    pasi->fRequireServerVerification = IsDlgButtonChecked(hDlg, IDC_CHECK_REQUIRE_SERVER_VERIFICATION);                 

                    if (pasi->fRequireServerVerification)
                        pasi->pSec->pszs->dwFlags |= ZAFLAGS_REQUIRE_VERIFICATION;
                    else
                        pasi->pSec->pszs->dwFlags &= ~ZAFLAGS_REQUIRE_VERIFICATION;

                    za.cbSize = sizeof(ZONEATTRIBUTES);
                    pasi->pSec->pInternetZoneManager->GetZoneAttributes(pasi->pSec->pszs->dwZoneIndex, &za);
                    za.dwFlags = pasi->pSec->pszs->dwFlags;
                    pasi->pSec->pInternetZoneManager->SetZoneAttributes(pasi->pSec->pszs->dwZoneIndex, &za);
                    if (SUCCEEDED(_AddSite(pasi)))
                    {
                        SecurityChanged();
                        EndDialog(hDlg, IDOK);
                    }
                    break;
                }

                case IDCANCEL:
                {
                    ZONEATTRIBUTES za;

                    // reset to original state of RequireServerVerification on cancel
                    za.cbSize = sizeof(ZONEATTRIBUTES);
                    pasi->pSec->pInternetZoneManager->GetZoneAttributes(pasi->pSec->pszs->dwZoneIndex, &za);
                    za.dwFlags = pasi->pSec->pszs->dwFlags;
                    pasi->pSec->pInternetZoneManager->SetZoneAttributes(pasi->pSec->pszs->dwZoneIndex, &za);

                    EndDialog(hDlg, IDCANCEL);
                    break;
                }
                
                case IDC_LIST_WEBSITES:
                    switch (HIWORD(wParam))
                    {
                        case LBN_SELCHANGE:
                        case LBN_SELCANCEL:
                            if (!pasi->pSec->fNoAddSites && !pasi->pSec->fNoZoneMapEdit)
                                EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_REMOVE), SendDlgItemMessage(hDlg, IDC_LIST_WEBSITES, LB_GETCURSEL, 0, 0) != -1);
                            break;
                    }
                    break;
                            
                case IDC_EDIT_ADD_SITE:
                    switch(HIWORD(wParam))
                    {
                        case EN_CHANGE:
                            BOOL fEnable = GetWindowTextLength(GetDlgItem(hDlg, IDC_EDIT_ADD_SITE)) ? TRUE:FALSE;
                            EnableWindow(GetDlgItem(hDlg,IDC_BUTTON_ADD), fEnable);
                            SendMessage(hDlg, DM_SETDEFID, fEnable ? IDC_BUTTON_ADD : IDOK, 0);
                            break;
                    }   
                    break;

                case IDC_BUTTON_ADD:
                    _AddSite(pasi);
                    break;

                case IDC_BUTTON_REMOVE:
                {
                    TCHAR szMapping[MAX_ZONE_PATH];
                    LPWSTR psz;
                    
                            
                    INT_PTR iSel = SendMessage(pasi->hwndWebSites, LB_GETCURSEL, 0, 0);
                    if (iSel != -1)
                    {
                        SendMessage(pasi->hwndWebSites, LB_GETTEXT, (WPARAM)iSel, (LPARAM)szMapping);
#ifndef UNICODE
                        WCHAR wszMapping[MAX_ZONE_PATH];
                        MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szMapping, sizeof(szMapping),  wszMapping, ARRAYSIZE(wszMapping));
                        psz = wszMapping;
#else
                        psz = szMapping;
#endif
                        SendMessage(pasi->hwndWebSites, LB_DELETESTRING, iSel , 0);
                        SendMessage(pasi->hwndWebSites, LB_SETCURSEL, iSel-1, 0);
                        if (!pasi->pSec->fNoAddSites && !pasi->pSec->fNoZoneMapEdit)
                            EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_REMOVE), SendDlgItemMessage(hDlg, IDC_LIST_WEBSITES, LB_GETCURSEL, 0, 0) != -1);

                        pasi->pSec->pInternetSecurityManager->SetZoneMapping(pasi->pSec->pszs->dwZoneIndex,
                            psz, SZM_DELETE);
                    }

                    break;
                }
                default:
                    return FALSE;
            }
            return TRUE;                
            break;

        case WM_HELP:           // F1
            ResWinHelp( (HWND)((LPHELPINFO)lParam)->hItemHandle, IDS_HELPFILE,
                        HELP_WM_HELP, (DWORD_PTR)(LPSTR)mapIDCsToIDHs);
            break;

        case WM_CONTEXTMENU:        // right mouse click
            ResWinHelp( (HWND) wParam, IDS_HELPFILE,
                        HELP_CONTEXTMENU, (DWORD_PTR)(LPSTR)mapIDCsToIDHs);
            break;

        case WM_DESTROY:
            SHRemoveDefaultDialogFont(hDlg);
            if (pasi)
            {
                LocalFree(pasi);
                SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)NULL);
            }
            break;
    }
    return FALSE;
}

INT_PTR CALLBACK SecurityAddSitesIntranetDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,LPARAM lParam)
{
    LPADDSITESINTRANETINFO pasii;

    if (uMsg == WM_INITDIALOG)
    {
        pasii = (LPADDSITESINTRANETINFO)LocalAlloc(LPTR, sizeof(*pasii));
        if (!pasii)
        {
            EndDialog(hDlg, IDCANCEL);
            return FALSE;
        }

        // tell dialog where to get info
        SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)pasii);

        // save the handle to the page
        pasii->hDlg = hDlg;
        pasii->pSec = (LPSECURITYPAGE)lParam;

        SendMessage(hDlg, WM_SETTEXT, (WPARAM)0, (LPARAM)pasii->pSec->pszs->szDisplayName);
        CheckDlgButton(hDlg, IDC_CHECK_USEINTRANET, pasii->pSec->pszs->dwFlags & ZAFLAGS_INCLUDE_INTRANET_SITES);
        CheckDlgButton(hDlg, IDC_CHECK_PROXY, pasii->pSec->pszs->dwFlags & ZAFLAGS_INCLUDE_PROXY_OVERRIDE);
        CheckDlgButton(hDlg, IDC_CHECK_UNC, pasii->pSec->pszs->dwFlags & ZAFLAGS_UNC_AS_INTRANET);
        SendDlgItemMessage(hDlg, IDC_ZONE_ICON, STM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)pasii->pSec->pszs->hicon);

        if (pasii->pSec->fNoAddSites || pasii->pSec->fNoZoneMapEdit)
        {
            EnableDlgItem(hDlg, IDC_CHECK_USEINTRANET, FALSE);
            EnableDlgItem(hDlg, IDC_CHECK_PROXY, FALSE);
        }

        if (pasii->pSec->fNoZoneMapEdit)
        {
            EnableDlgItem(hDlg, IDC_CHECK_UNC, FALSE);
        }
        return TRUE;
    }

    else
         pasii = (LPADDSITESINTRANETINFO)GetWindowLongPtr(hDlg, DWLP_USER);

    if (!pasii)
        return FALSE;
    
    switch (uMsg) {
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDOK:
                {
                    ZONEATTRIBUTES za;

                    pasii->fUseIntranet       = IsDlgButtonChecked(hDlg, IDC_CHECK_USEINTRANET);
                    pasii->fUseProxyExclusion = IsDlgButtonChecked(hDlg, IDC_CHECK_PROXY);
                    pasii->fUseUNC            = IsDlgButtonChecked(hDlg, IDC_CHECK_UNC);
                    
                    if (pasii->fUseIntranet)
                        pasii->pSec->pszs->dwFlags |= ZAFLAGS_INCLUDE_INTRANET_SITES;
                    else
                        pasii->pSec->pszs->dwFlags &= ~ZAFLAGS_INCLUDE_INTRANET_SITES;

                    if (pasii->fUseProxyExclusion)
                        pasii->pSec->pszs->dwFlags |= ZAFLAGS_INCLUDE_PROXY_OVERRIDE;
                    else
                        pasii->pSec->pszs->dwFlags &= ~ZAFLAGS_INCLUDE_PROXY_OVERRIDE;

                    if (pasii->fUseUNC)
                        pasii->pSec->pszs->dwFlags |= ZAFLAGS_UNC_AS_INTRANET;
                    else
                        pasii->pSec->pszs->dwFlags &= ~ZAFLAGS_UNC_AS_INTRANET;
                    
                    za.cbSize = sizeof(ZONEATTRIBUTES);
                    pasii->pSec->pInternetZoneManager->GetZoneAttributes(pasii->pSec->pszs->dwZoneIndex, &za);
                    za.dwFlags = pasii->pSec->pszs->dwFlags;
                    pasii->pSec->pInternetZoneManager->SetZoneAttributes(pasii->pSec->pszs->dwZoneIndex, &za);
                    SecurityChanged();
                    EndDialog(hDlg, IDOK);
                    break;
                }
                case IDCANCEL:
                    EndDialog(hDlg, IDCANCEL);
                    break;

                case IDC_INTRANET_ADVANCED:
                    DialogBoxParam(MLGetHinst(), MAKEINTRESOURCE(IDD_SECURITY_ADD_SITES), hDlg,
                                   SecurityAddSitesDlgProc, (LPARAM)pasii->pSec);
                    break;

                default:
                    return FALSE;
            }
            return TRUE;                
            break;

        case WM_HELP:           // F1
            ResWinHelp( (HWND)((LPHELPINFO)lParam)->hItemHandle, IDS_HELPFILE,
                        HELP_WM_HELP, (DWORD_PTR)(LPSTR)mapIDCsToIDHs);
            break;

        case WM_CONTEXTMENU:        // right mouse click
            ResWinHelp( (HWND) wParam, IDS_HELPFILE,
                        HELP_CONTEXTMENU, (DWORD_PTR)(LPSTR)mapIDCsToIDHs);
            break;

        case WM_DESTROY:
            if (pasii)
            {
                LocalFree(pasii);
                SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)NULL);
            }
            break;
    }
    return FALSE;
}

VOID ShowJavaZonePermissionsDialog (HWND hdlg, LPCUSTOMSETTINGSINFO pcsi)
{
    HRESULT           hr;
    IJavaZonePermissionEditor *zoneeditor;

    hr = CoCreateInstance(
            CLSID_JavaRuntimeConfiguration,
            NULL,
            CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER,
            IID_IJavaZonePermissionEditor,
            (PVOID*)&zoneeditor
            );

    if (SUCCEEDED(hr))
    {
        hr = zoneeditor->ShowUI(
                hdlg,
                0,
                0,
                pcsi->fUseHKLM ? URLZONEREG_HKLM : URLZONEREG_DEFAULT,
                pcsi->pSec->pszs->dwZoneIndex,
                pcsi->dwJavaPolicy | URLACTION_JAVA_PERMISSIONS,
                pcsi->pSec->pInternetZoneManager
                );

        zoneeditor->Release();
    }
}



void ShowCustom(LPCUSTOMSETTINGSINFO pcsi, HTREEITEM hti)
{
    TV_ITEM        tvi;
    tvi.hItem = hti;
    tvi.mask = TVIF_HANDLE | TVIF_PARAM | TVIF_IMAGE;

    TreeView_GetItem( pcsi->hwndTree, &tvi );

        // If it's not selected don't bother.
    if (tvi.iImage != IDRADIOON)
        return;

    TCHAR szValName[64];
    DWORD cb = SIZEOF(szValName);
    DWORD dwChecked;

    if (SHRegQueryUSValue((HUSKEY)tvi.lParam,
                        TEXT("ValueName"),
                        NULL,
                        (LPBYTE)szValName,
                        &cb,
                        pcsi->fUseHKLM,
                        NULL,
                        0) == ERROR_SUCCESS)
    {
        if (!(StrCmp(szValName, TEXT("1C00"))))
        {
            cb = SIZEOF(dwChecked);
            if (SHRegQueryUSValue((HUSKEY)tvi.lParam,
                                TEXT("CheckedValue"),
                                NULL,
                                (LPBYTE)&dwChecked,
                                &cb,
                                pcsi->fUseHKLM,
                                NULL,
                                0) == ERROR_SUCCESS)
            {
#ifndef UNIX
                HWND hCtl = GetDlgItem(pcsi->hDlg, IDC_JAVACUSTOM);
                ShowWindow(hCtl,
                           (dwChecked == URLPOLICY_JAVA_CUSTOM) && (tvi.iImage == IDRADIOON) ? SW_SHOWNA : SW_HIDE);
                EnableWindow(hCtl, dwChecked==URLPOLICY_JAVA_CUSTOM ? TRUE : FALSE);
                pcsi->dwJavaPolicy = dwChecked;
#endif
            }
        }
    }
}

void _FindCustomRecursive(
    LPCUSTOMSETTINGSINFO pcsi,
    HTREEITEM htvi
)
{
    HTREEITEM hctvi;    // child
    
    // step through the children
    hctvi = TreeView_GetChild( pcsi->hwndTree, htvi );
    while ( hctvi )
    {
        _FindCustomRecursive(pcsi,hctvi);
        hctvi = TreeView_GetNextSibling( pcsi->hwndTree, hctvi );
    }

    ShowCustom(pcsi, htvi);
}

void _FindCustom(
    LPCUSTOMSETTINGSINFO pcsi
    )
{
    HTREEITEM hti = TreeView_GetRoot( pcsi->hwndTree );
    
    // and walk the list of other roots
    while (hti)
    {
        // recurse through its children
        _FindCustomRecursive(pcsi, hti);

        // get the next root
        hti = TreeView_GetNextSibling(pcsi->hwndTree, hti );
    }
}

BOOL SecurityCustomSettingsInitDialog(HWND hDlg, LPARAM lParam)
{
    LPCUSTOMSETTINGSINFO pcsi = (LPCUSTOMSETTINGSINFO)LocalAlloc(LPTR, sizeof(*pcsi));
    HRESULT hr;
    
    if (!pcsi)
    {
        EndDialog(hDlg, IDCANCEL);
        return FALSE;
    }
    
    // tell dialog where to get info
    SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)pcsi);

    // save the handle to the page
    pcsi->hDlg = hDlg;
    pcsi->pSec = (LPSECURITYPAGE)lParam;

    // save dialog handle
    pcsi->hwndTree = GetDlgItem(pcsi->hDlg, IDC_TREE_SECURITY_SETTINGS);

    CoInitialize(0);
    hr = CoCreateInstance(CLSID_CRegTreeOptions, NULL, CLSCTX_INPROC_SERVER,
                          IID_IRegTreeOptions, (LPVOID *)&(pcsi->pTO));


    DWORD cb = SIZEOF(pcsi->fUseHKLM);
    
    SHGetValue(HKEY_LOCAL_MACHINE,
               REGSTR_PATH_SECURITY_LOCKOUT,
               REGSTR_VAL_HKLM_ONLY,
               NULL,
               &(pcsi->fUseHKLM),
               &cb);

    // if this fails, we'll just use the default of fUseHKLM == 0
               
    if (SUCCEEDED(hr))
    {
        CHAR szZone[32];

        wnsprintfA(szZone, ARRAYSIZE(szZone), "%ld", pcsi->pSec->pszs->dwZoneIndex);

        // use the SOHKLM tree when fUseHKLM==TRUE for IEAK
        hr = pcsi->pTO->InitTree(pcsi->hwndTree, HKEY_LOCAL_MACHINE,
                                 pcsi->fUseHKLM ?
                                 "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\SOIEAK" :
                                 "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\SO",
                                 szZone);
    }
    
    // find the first root and make sure that it is visible
    TreeView_EnsureVisible( pcsi->hwndTree, TreeView_GetRoot( pcsi->hwndTree ) );

    pcsi->hwndCombo = GetDlgItem(hDlg, IDC_COMBO_RESETLEVEL);
    
    SendMessage(pcsi->hwndCombo, CB_INSERTSTRING, (WPARAM)0, (LPARAM)LEVEL_NAME[3]);
    SendMessage(pcsi->hwndCombo, CB_INSERTSTRING, (WPARAM)0, (LPARAM)LEVEL_NAME[2]);
    SendMessage(pcsi->hwndCombo, CB_INSERTSTRING, (WPARAM)0, (LPARAM)LEVEL_NAME[1]);
    SendMessage(pcsi->hwndCombo, CB_INSERTSTRING, (WPARAM)0, (LPARAM)LEVEL_NAME[0]);
    
    switch (pcsi->pSec->pszs->dwRecSecLevel)
    {
        case URLTEMPLATE_LOW:
            pcsi->iLevelSel = 3;
            break;
        case URLTEMPLATE_MEDLOW:
            pcsi->iLevelSel = 2;
            break;
        case URLTEMPLATE_MEDIUM:
            pcsi->iLevelSel = 1;
            break;
        case URLTEMPLATE_HIGH:
            pcsi->iLevelSel = 0;
            break;
        default:
            pcsi->iLevelSel = 0;
            break;
    }

    _FindCustom(pcsi);
    
    SendMessage(pcsi->hwndCombo, CB_SETCURSEL, (WPARAM)pcsi->iLevelSel, (LPARAM)0);

    if (pcsi->pSec->fNoEdit)
    {
        EnableDlgItem(hDlg, IDC_COMBO_RESETLEVEL, FALSE);
        EnableDlgItem(hDlg, IDC_BUTTON_APPLY, FALSE);
    }
    pcsi->fChanged = FALSE;
    return TRUE;
}

INT_PTR CALLBACK SecurityCustomSettingsDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,LPARAM lParam)
{
    LPCUSTOMSETTINGSINFO pcsi;

    if (uMsg == WM_INITDIALOG)
        return SecurityCustomSettingsInitDialog(hDlg, lParam);
    else
        pcsi = (LPCUSTOMSETTINGSINFO)GetWindowLongPtr(hDlg, DWLP_USER);
    
    if (!pcsi)
        return FALSE;
                
    switch (uMsg) {

        case WM_NOTIFY:
        {
            LPNMHDR psn = (LPNMHDR)lParam;
            switch( psn->code )
            {
                case TVN_KEYDOWN:
                {
                    TV_KEYDOWN *pnm = (TV_KEYDOWN*)psn;
                    if (pnm->wVKey == VK_SPACE) {
                        if (!pcsi->pSec->fNoEdit)
                        {
                            HTREEITEM hti = (HTREEITEM)SendMessage(pcsi->hwndTree, TVM_GETNEXTITEM, TVGN_CARET, NULL);
                            pcsi->pTO->ToggleItem(hti);
                            ShowCustom(pcsi, hti);
                            pcsi->fChanged = TRUE;
                            EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_APPLY),TRUE);
                            SetWindowLongPtr(hDlg, DWLP_MSGRESULT, TRUE); // eat the key
                            return TRUE;
                         }
                    }
                    break;
                }
            
                case NM_CLICK:
                case NM_DBLCLK:
                {   // is this click in our tree?
                    if ( psn->idFrom == IDC_TREE_SECURITY_SETTINGS )
                    {   // yes...
                        TV_HITTESTINFO ht;
                        HTREEITEM hti;

                        if (!pcsi->pSec->fNoEdit)
                        {
                            GetCursorPos( &ht.pt );                         // get where we were hit
                            ScreenToClient( pcsi->hwndTree, &ht.pt );       // translate it to our window

                            // retrieve the item hit
                            hti = TreeView_HitTest( pcsi->hwndTree, &ht);

                            pcsi->pTO->ToggleItem(hti);
                            pcsi->fChanged = TRUE;
                            ShowCustom(pcsi, hti);
                            EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_APPLY),TRUE);
                         }
                    }   
                }
                break;
            }
        }
        break;
        
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDOK:
                    if(pcsi->pSec->fPendingChange)
                        break;
                    
                    if(pcsi->fChanged && RegWriteWarning(pcsi->pSec->hDlg) == IDNO)
                        break;
                    // we use send message instead of post because there is no chance of this button
                    // receiving multiple signals at one click, and we need the change level message to be
                    // processed before the apply message below
                    pcsi->pSec->fPendingChange = TRUE;
                    SendMessage(pcsi->pSec->hDlg, WM_APP, (WPARAM) 0, (LPARAM) URLTEMPLATE_CUSTOM);
                    if(pcsi->fChanged)
                    {
                        pcsi->pTO->WalkTree( WALK_TREE_SAVE );
                    }
                    // Saves custom to registry and Handles updateallwindows 
                    // and securitychanged calls

                    // APPCOMPAT: Force a call to SetZoneAttributes when anything in custom changes.
                    // This forces the security manager to flush any caches it has for that zone. 
                    pcsi->pSec->fChanged = TRUE;

                    SecurityDlgApplyNow(pcsi->pSec, FALSE);
                    EndDialog(hDlg, IDOK);
                    break;

                case IDCANCEL:
                    EndDialog(hDlg, IDCANCEL);
                    break;

                case IDC_COMBO_RESETLEVEL:
                    switch (HIWORD(wParam))
                    {
                        case CBN_SELCHANGE:
                        {
                            // Sundown: coercion to integer since cursor selection is 32b
                            int iNewSelection = (int) SendMessage(pcsi->hwndCombo, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);

                            if (iNewSelection != pcsi->iLevelSel)
                            {
                                pcsi->iLevelSel = iNewSelection;
                                EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_APPLY),TRUE);
                            }
                            break;
                        }
                    }
                    break;

                case IDC_JAVACUSTOM:
                    ShowJavaZonePermissionsDialog(hDlg, pcsi);
                    break;
                    
                case IDC_BUTTON_APPLY:
                {
                    TCHAR szLevel[64];
                    ZONEATTRIBUTES za;
                    
                    if(pcsi->pSec->fPendingChange == TRUE)
                        break;
                    if(RegWriteWarning(hDlg) == IDNO)
                    {
                        break;
                    }
                    pcsi->pSec->fPendingChange = TRUE;

                    SendMessage(pcsi->hwndCombo, WM_GETTEXT, (WPARAM)ARRAYSIZE(szLevel), (LPARAM)szLevel);

                    za.cbSize = sizeof(ZONEATTRIBUTES);
                        
                    pcsi->pSec->pInternetZoneManager->GetZoneAttributes(pcsi->pSec->pszs->dwZoneIndex, &za);
                                
                    if (!StrCmp(szLevel, LEVEL_NAME[3])) 
                        za.dwTemplateCurrentLevel = URLTEMPLATE_LOW;
                    else if (!StrCmp(szLevel, LEVEL_NAME[2]))
                        za.dwTemplateCurrentLevel = URLTEMPLATE_MEDLOW;
                    else if (!StrCmp(szLevel, LEVEL_NAME[1]))
                        za.dwTemplateCurrentLevel = URLTEMPLATE_MEDIUM;
                    else if (!StrCmp(szLevel, LEVEL_NAME[0]))
                        za.dwTemplateCurrentLevel = URLTEMPLATE_HIGH;
                    else
                        za.dwTemplateCurrentLevel = URLTEMPLATE_CUSTOM;

                    pcsi->pSec->pInternetZoneManager->SetZoneAttributes(pcsi->pSec->pszs->dwZoneIndex, &za);

                    pcsi->pTO->WalkTree(WALK_TREE_REFRESH);

                    // find the first root and make sure that it is visible
                    TreeView_EnsureVisible( pcsi->hwndTree, TreeView_GetRoot( pcsi->hwndTree ) );
                    EnableWindow(GetDlgItem(hDlg, IDC_BUTTON_APPLY), FALSE);
                    SendMessage(hDlg, DM_SETDEFID, IDOK, 0);
                    SetFocus(GetDlgItem(hDlg, IDOK));   // since we grayout the reset button, might have keyboard
                                                        // focus, so we should set focus somewhere else
                    _FindCustom(pcsi);

                    // BUG #57358. We tell the Zone Manager to change to [High/Med/Low] level because we want
                    //             the policy values for those, but we don't want it to change the level from
                    //             custom.  So, after it changes the setting from Custom, we change it back.
                    // Save the level as custom

                    // we use send message instead of post because there is no chance of this button
                    // receiving multiple signals at one click, and we need the change level message to be
                    // processed before the apply message below
                    SendMessage(pcsi->pSec->hDlg, WM_APP, (WPARAM) 0, (LPARAM) URLTEMPLATE_CUSTOM);

                    // Saves custom to registry and Handles updateallwindows 
                    // and securitychanged calls

                    // APPCOMPAT: Force a call to SetZoneAttributes when anything in custom changes.
                    // This forces the security manager to flush any caches it has for that zone. 
                    pcsi->pSec->fChanged = TRUE;

                    SecurityDlgApplyNow(pcsi->pSec, TRUE);

                    pcsi->fChanged = FALSE;
                    break;
                }
                    

                default:
                    return FALSE;
            }
            return TRUE;                
            break;

        case WM_HELP:           // F1
        {
            LPHELPINFO lphelpinfo;
            lphelpinfo = (LPHELPINFO)lParam;

            TV_HITTESTINFO ht;
            HTREEITEM hItem;

            // If this help is invoked through the F1 key.
            if (GetAsyncKeyState(VK_F1) < 0)
            {
                // Yes we need to give help for the currently selected item.
                hItem = TreeView_GetSelection(pcsi->hwndTree);
            }
            else
            {
                // Else we need to give help for the item at current cursor position
                ht.pt =((LPHELPINFO)lParam)->MousePos;
                ScreenToClient(pcsi->hwndTree, &ht.pt); // Translate it to our window
                hItem = TreeView_HitTest(pcsi->hwndTree, &ht);
            }

                        
            if (FAILED(pcsi->pTO->ShowHelp(hItem , HELP_WM_HELP)))
            {
                ResWinHelp( (HWND)((LPHELPINFO)lParam)->hItemHandle, IDS_HELPFILE,
                            HELP_WM_HELP, (DWORD_PTR)(LPSTR)mapIDCsToIDHs);
            }
            break; 

        }
        case WM_CONTEXTMENU:        // right mouse click
        {
            TV_HITTESTINFO ht;

            GetCursorPos( &ht.pt );                         // get where we were hit
            ScreenToClient( pcsi->hwndTree, &ht.pt );       // translate it to our window

            // retrieve the item hit
            if (FAILED(pcsi->pTO->ShowHelp(TreeView_HitTest( pcsi->hwndTree, &ht),HELP_CONTEXTMENU)))
            {           
                ResWinHelp( (HWND) wParam, IDS_HELPFILE,
                            HELP_CONTEXTMENU, (DWORD_PTR)(LPSTR)mapIDCsToIDHs);
            }
            break; 
        }
        case WM_DESTROY:
            if (pcsi)
            {
                if (pcsi->pTO)
                {
                    pcsi->pTO->WalkTree( WALK_TREE_DELETE );
                    pcsi->pTO->Release();
                    pcsi->pTO=NULL;
                }
                
                LocalFree(pcsi);
                SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)NULL);
                CoUninitialize();
            }
            break;
    }
    return FALSE;
}

#ifdef UNIX
extern "C" 
#endif
BOOL LaunchSecurityDialogEx(HWND hDlg, DWORD dwZone, DWORD dwFlags)
{
    INITCOMMONCONTROLSEX icex;
    SECURITYINITFLAGS * psif = NULL;

    icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
    icex.dwICC  = ICC_USEREX_CLASSES|ICC_NATIVEFNTCTL_CLASS;
    InitCommonControlsEx(&icex);

    if(g_dwtlsSecInitFlags != (DWORD) -1)
        psif = (SECURITYINITFLAGS *) TlsGetValue(g_dwtlsSecInitFlags);
    if(psif)
    {
        psif->fForceUI = dwFlags & LSDFLAG_FORCEUI;
        psif->fDisableAddSites = dwFlags & LSDFLAG_NOADDSITES;
        psif->dwZone = dwZone;
    }

    // passing in a NULL psif is okay
    DialogBoxParam(MLGetHinst(), MAKEINTRESOURCE(IDD_SECSTANDALONE), hDlg,
                           SecurityDlgProc, (LPARAM) psif);
    
    return TRUE;
}

// backwards compatability
#ifdef UNIX
extern "C"
#endif
void LaunchSecurityDialog(HWND hDlg, DWORD dwZone)
{
    LaunchSecurityDialogEx(hDlg, dwZone, LSDFLAG_DEFAULT);
}

#ifdef UNIX
extern "C" 
#endif
void LaunchSiteCertDialog(HWND hDlg)
{
    CRYPTUI_CERT_MGR_STRUCT ccm = {0};
    ccm.dwSize = sizeof(ccm);
    ccm.hwndParent = hDlg;
    CryptUIDlgCertMgr(&ccm);
}