windows-xp/Source/XPSP1/NT/admin/snapin/certmgr/cmponent.cpp

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1997-2001.
//
//  File:         cmponent.cpp
//
//  Contents:   Implementation of CCertMgrComponent
//
//----------------------------------------------------------------------------

#include "stdafx.h"

#include <gpedit.h>
#include <wintrust.h>
#include <sceattch.h>
#include "compdata.h" // CCertMgrComponentData
#include "dataobj.h"
#include "cmponent.h" // CCertMgrComponent
#include "storegpe.h"
#include "users.h"
#include "addsheet.h"
#include "StoreRSOP.h"
#include "SaferEntry.h"


#ifdef _DEBUG
#ifndef ALPHA
#define new DEBUG_NEW
#endif
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

USE_HANDLE_MACROS ("CERTMGR (cmponent.cpp)")
#include "stdcmpnt.cpp" // CComponent

extern bool g_bSchemaIsW2K;

extern GUID g_guidExtension;
extern GUID g_guidRegExt;
extern GUID g_guidSnapin;

// CERTMGR_USAGE, CERTMGR_USAGE, CERTMGR_USAGE, CERTMGR_CERT_CONTAINER
UINT m_aColumns0[CERT_NUM_COLS+1] =
	{IDS_COLUMN_SUBJECT, IDS_COLUMN_ISSUER, IDS_COLUMN_EXPIRATION_DATE, 
        IDS_COLUMN_PURPOSE, IDS_COLUMN_FRIENDLY_NAME, IDS_COLUMN_STATUS, 
        IDS_COLUMN_TEMPLATE_NAME, 0};
// CERTMGR_SNAPIN
UINT m_aColumns1[2] =
	{IDS_COLUMN_LOG_CERTIFICATE_STORE,0};
// CERTMGR_CERTIFICATE, CERTMGR_CRL, CERTMGR_CTL
UINT m_aColumns2[2] =
	{0,0};
// CERTMGR_CRL_CONTAINER
UINT m_aColumns3[4] =
	{IDS_COLUMN_ISSUER, IDS_COLUMN_EFFECTIVE_DATE, IDS_COLUMN_NEXT_UPDATE, 0};
// CERTMGR_CTL_CONTAINER
UINT m_aColumns4[6] =
	{IDS_COLUMN_ISSUER, IDS_COLUMN_EFFECTIVE_DATE, IDS_COLUMN_PURPOSE, IDS_COLUMN_FRIENDLY_NAME, 0};

UINT m_aColumns5[2] =
	{IDS_COLUMN_OBJECT_TYPE, 0};

// CERTMGR_SAFER_USER_LEVELS, CERTMGR_SAFER_COMPUTER_LEVELS
UINT m_aColumns6[SAFER_LEVELS_NUM_COLS+1] =
    {IDS_COLUMN_NAME, IDS_COLUMN_DESCRIPTION, 0};

// CERTMGR_SAFER_USER_ENTRIES, CERTMGR_SAFER_COMPUTER_ENTRIES
UINT m_aColumns7[SAFER_ENTRIES_NUM_COLS+1] =
{IDS_COLUMN_NAME, IDS_COLUMN_TYPE, IDS_COLUMN_LEVEL, IDS_COLUMN_DESCRIPTION, IDS_COLUMN_LAST_MODIFIED_DATE, 0};

UINT* m_Columns[CERTMGR_NUMTYPES] =
	{	
		m_aColumns1, // CERTMGR_SNAPIN
		m_aColumns2, // CERTMGR_CERTIFICATE (result)
		m_aColumns5, // CERTMGR_LOG_STORE
		m_aColumns5, // CERTMGR_PHYS_STORE
		m_aColumns0, // CERTMGR_USAGE
		m_aColumns3, // CERTMGR_CRL_CONTAINER
		m_aColumns4, // CERTMGR_CTL_CONTAINER
		m_aColumns0, // CERTMGR_CERT_CONTAINER
		m_aColumns2, // CERTMGR_CRL (result)
		m_aColumns2, // CERTMGR_CTL (result)
		m_aColumns2, // CERTMGR_AUTO_CERT_REQUEST
		m_aColumns5, //	CERTMGR_CERT_POLICIES_USER,
		m_aColumns5, // CERTMGR_CERT_POLICIES_COMPUTER,
		m_aColumns5, // CERTMGR_LOG_STORE_GPE
		m_aColumns5, // CERTMGR_LOG_STORE_RSOP
        m_aColumns1, // CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS
        m_aColumns1, // CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS
        m_aColumns5, // CERTMGR_SAFER_COMPUTER_ROOT
        m_aColumns5, // CERTMGR_SAFER_USER_ROOT
        m_aColumns6, // CERTMGR_SAFER_COMPUTER_LEVELS
        m_aColumns6, // CERTMGR_SAFER_USER_LEVELS
        m_aColumns7, // CERTMGR_SAFER_COMPUTER_ENTRIES
        m_aColumns7, // CERTMGR_SAFER_USER_ENTRIES
        m_aColumns2, // CERTMGR_SAFER_COMPUTER_LEVEL,
        m_aColumns2, // CERTMGR_SAFER_USER_LEVEL,
        m_aColumns2, // CERTMGR_SAFER_COMPUTER_ENTRY,
        m_aColumns2, // CERTMGR_SAFER_USER_ENTRY,
        m_aColumns2, // CERTMGR_SAFER_COMPUTER_TRUSTED_PUBLISHERS
        m_aColumns2, // CERTMGR_SAFER_USER_TRUSTED_PUBLISHERS
        m_aColumns2, // CERTMGR_SAFER_COMPUTER_DEFINED_FILE_TYPES
        m_aColumns2, // CERTMGR_SAFER_USER_DEFINED_FILE_TYPES
        m_aColumns2, // CERTMGR_SAFER_USER_ENFORCEMENT
        m_aColumns2  // CERTMGR_SAFER_COMPUTER_ENFORCEMENT
	};


UINT** g_aColumns = 0;	// for framework
int** g_aColumnWidths = 0;  // for framework
const int SINGLE_COL_WIDTH = 450;

CCertMgrComponent::CCertMgrComponent ()
:   m_pViewedCookie (NULL),
	m_bUsageStoresEnumerated (false),
	m_pPastedDO (NULL),
	m_bShowArchivedCertsStateWhenLogStoresEnumerated (false),
    m_nSelectedCertColumn (0),
    m_nSelectedCRLColumn (0),
    m_nSelectedCTLColumn (0),
    m_nSelectedSaferEntryColumn (0),
    m_pLastUsageCookie (0),
    m_pControlbar (0),
    m_pToolbar (0)
{
     AFX_MANAGE_STATE (AfxGetStaticModuleState ( ));
	_TRACE (1, L"Entering CCertMgrComponent::CCertMgrComponent\n");

	const int ISSUED_TO_BY_WIDTH = 200;
	const int FRIENDLY_NAME_WIDTH = 125;
	const int DATE_WIDTH = 100;
	const int PURPOSE_WIDTH = 125;
	const int STATUS_WIDTH = 50;
    const int TEMPLATE_WIDTH = 100;
    const int SAFER_LEVEL_NAME_WIDTH = 150;
    const int SAFER_LEVEL_DESCRIPTION_WIDTH = 400;
    const int SAFER_ENTRY_NAME_WIDTH = 250;
    const int SAFER_ENTRY_TYPE_WIDTH = 75;
    const int SAFER_ENTRY_LEVEL_WIDTH = 100;
    const int SAFER_ENTRY_DESCRIPTION_WIDTH = 200;
    const int SAFER_ENTRY_LAST_MODIFIED_DATE_WIDTH = 200;

    ::ZeroMemory (m_ColumnWidths, sizeof (UINT*) * CERTMGR_NUMTYPES);
	m_ColumnWidths[CERTMGR_SNAPIN] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_SNAPIN] )
		m_ColumnWidths[CERTMGR_SNAPIN][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_USAGE] = new UINT[CERT_NUM_COLS];
	if ( m_ColumnWidths[CERTMGR_USAGE] )
	{
		m_ColumnWidths[CERTMGR_USAGE][COLNUM_CERT_SUBJECT] = ISSUED_TO_BY_WIDTH;    // issued to
		m_ColumnWidths[CERTMGR_USAGE][COLNUM_CERT_ISSUER] = ISSUED_TO_BY_WIDTH;		// issued by
		m_ColumnWidths[CERTMGR_USAGE][COLNUM_CERT_EXPIRATION_DATE] = DATE_WIDTH;	// expiration date
		m_ColumnWidths[CERTMGR_USAGE][COLNUM_CERT_PURPOSE] = PURPOSE_WIDTH;			// purpose
		m_ColumnWidths[CERTMGR_USAGE][COLNUM_CERT_CERT_NAME] = FRIENDLY_NAME_WIDTH;	// friendly name
		m_ColumnWidths[CERTMGR_USAGE][COLNUM_CERT_STATUS] = STATUS_WIDTH;			// status
		m_ColumnWidths[CERTMGR_USAGE][COLNUM_CERT_TEMPLATE] = TEMPLATE_WIDTH;		// template
	}

	m_ColumnWidths[CERTMGR_PHYS_STORE] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_PHYS_STORE] )
		m_ColumnWidths[CERTMGR_PHYS_STORE][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_LOG_STORE] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_LOG_STORE] )
		m_ColumnWidths[CERTMGR_LOG_STORE][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_CERTIFICATE] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_CERTIFICATE] )
		m_ColumnWidths[CERTMGR_CERTIFICATE][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_CRL_CONTAINER] = new UINT[CRL_NUM_COLS];
	if ( m_ColumnWidths[CERTMGR_CRL_CONTAINER] )
	{
		m_ColumnWidths[CERTMGR_CRL_CONTAINER][0] = ISSUED_TO_BY_WIDTH; // issued by
		m_ColumnWidths[CERTMGR_CRL_CONTAINER][1] = DATE_WIDTH;	// effective date
		m_ColumnWidths[CERTMGR_CRL_CONTAINER][2] = DATE_WIDTH;	// next update
	}

	m_ColumnWidths[CERTMGR_CTL_CONTAINER] = new UINT[CTL_NUM_COLS];
	if ( m_ColumnWidths[CERTMGR_CTL_CONTAINER] )
	{
		m_ColumnWidths[CERTMGR_CTL_CONTAINER][0] = ISSUED_TO_BY_WIDTH;	// issued by
		m_ColumnWidths[CERTMGR_CTL_CONTAINER][1] = DATE_WIDTH;	// effective date
		m_ColumnWidths[CERTMGR_CTL_CONTAINER][2] = PURPOSE_WIDTH;	// purpose
		m_ColumnWidths[CERTMGR_CTL_CONTAINER][3] = FRIENDLY_NAME_WIDTH;	// friendly name
	}

	m_ColumnWidths[CERTMGR_CERT_CONTAINER] = new UINT[CERT_NUM_COLS];
	if ( m_ColumnWidths[CERTMGR_CERT_CONTAINER] )
	{
		m_ColumnWidths[CERTMGR_CERT_CONTAINER][COLNUM_CERT_SUBJECT] = ISSUED_TO_BY_WIDTH;	// issued to
		m_ColumnWidths[CERTMGR_CERT_CONTAINER][COLNUM_CERT_ISSUER] = ISSUED_TO_BY_WIDTH;	// issued by
		m_ColumnWidths[CERTMGR_CERT_CONTAINER][COLNUM_CERT_EXPIRATION_DATE] = DATE_WIDTH;	// expiration date
		m_ColumnWidths[CERTMGR_CERT_CONTAINER][COLNUM_CERT_PURPOSE] = PURPOSE_WIDTH;		// purpose
		m_ColumnWidths[CERTMGR_CERT_CONTAINER][COLNUM_CERT_CERT_NAME] = FRIENDLY_NAME_WIDTH;// friendly name
		m_ColumnWidths[CERTMGR_CERT_CONTAINER][COLNUM_CERT_STATUS] = STATUS_WIDTH;			// status
		m_ColumnWidths[CERTMGR_CERT_CONTAINER][COLNUM_CERT_TEMPLATE] = TEMPLATE_WIDTH;		// template
	}

	m_ColumnWidths[CERTMGR_CRL] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_CRL] )
		m_ColumnWidths[CERTMGR_CRL][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_CTL] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_CTL] )
		m_ColumnWidths[CERTMGR_CTL][0] = SINGLE_COL_WIDTH;

     m_ColumnWidths[CERTMGR_LOG_STORE_GPE] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_LOG_STORE_GPE] )
		m_ColumnWidths[CERTMGR_LOG_STORE_GPE][0] = SINGLE_COL_WIDTH;

     m_ColumnWidths[CERTMGR_LOG_STORE_RSOP] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_LOG_STORE_RSOP] )
		m_ColumnWidths[CERTMGR_LOG_STORE_RSOP][0] = SINGLE_COL_WIDTH;

     m_ColumnWidths[CERTMGR_AUTO_CERT_REQUEST] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_AUTO_CERT_REQUEST] )
		m_ColumnWidths[CERTMGR_AUTO_CERT_REQUEST][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_CERT_POLICIES_USER] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_CERT_POLICIES_USER] )
		m_ColumnWidths[CERTMGR_CERT_POLICIES_USER][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_CERT_POLICIES_COMPUTER] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_CERT_POLICIES_COMPUTER] )
		m_ColumnWidths[CERTMGR_CERT_POLICIES_COMPUTER][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS] )
		m_ColumnWidths[CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS] )
		m_ColumnWidths[CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ROOT] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ROOT] )
		m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ROOT][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_SAFER_USER_ROOT] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_SAFER_USER_ROOT] )
		m_ColumnWidths[CERTMGR_SAFER_USER_ROOT][0] = SINGLE_COL_WIDTH;

    m_ColumnWidths[CERTMGR_SAFER_COMPUTER_LEVELS] = new UINT[SAFER_LEVELS_NUM_COLS];
	if ( m_ColumnWidths[CERTMGR_SAFER_COMPUTER_LEVELS] )
    {
		m_ColumnWidths[CERTMGR_SAFER_COMPUTER_LEVELS][COLNUM_SAFER_LEVEL_NAME] = SAFER_LEVEL_NAME_WIDTH;
		m_ColumnWidths[CERTMGR_SAFER_COMPUTER_LEVELS][COLNUM_SAFER_LEVEL_DESCRIPTION] = SAFER_LEVEL_DESCRIPTION_WIDTH;
    }

	m_ColumnWidths[CERTMGR_SAFER_USER_LEVELS] = new UINT[SAFER_LEVELS_NUM_COLS];
	if ( m_ColumnWidths[CERTMGR_SAFER_USER_LEVELS] )
    {
        m_ColumnWidths[CERTMGR_SAFER_USER_LEVELS][COLNUM_SAFER_LEVEL_NAME] = SAFER_LEVEL_NAME_WIDTH;
        m_ColumnWidths[CERTMGR_SAFER_USER_LEVELS][COLNUM_SAFER_LEVEL_DESCRIPTION] = SAFER_LEVEL_DESCRIPTION_WIDTH;
    }

	m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ENTRIES] = new UINT[SAFER_ENTRIES_NUM_COLS];
	if ( m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ENTRIES] )
    {
        m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ENTRIES][COLNUM_SAFER_ENTRIES_NAME] = SAFER_ENTRY_NAME_WIDTH;
        m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ENTRIES][COLNUM_SAFER_ENTRIES_TYPE] = SAFER_ENTRY_TYPE_WIDTH;
        m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ENTRIES][COLNUM_SAFER_ENTRIES_LEVEL] = SAFER_ENTRY_LEVEL_WIDTH;
        m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ENTRIES][COLNUM_SAFER_ENTRIES_DESCRIPTION] = SAFER_ENTRY_DESCRIPTION_WIDTH;
        m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ENTRIES][COLNUM_SAFER_ENTRIES_LAST_MODIFIED_DATE] = SAFER_ENTRY_LAST_MODIFIED_DATE_WIDTH;
    }

	m_ColumnWidths[CERTMGR_SAFER_USER_ENTRIES] = new UINT[SAFER_ENTRIES_NUM_COLS];
	if ( m_ColumnWidths[CERTMGR_SAFER_USER_ENTRIES] )
    {
        m_ColumnWidths[CERTMGR_SAFER_USER_ENTRIES][COLNUM_SAFER_ENTRIES_NAME] = SAFER_ENTRY_NAME_WIDTH;
        m_ColumnWidths[CERTMGR_SAFER_USER_ENTRIES][COLNUM_SAFER_ENTRIES_TYPE] = SAFER_ENTRY_TYPE_WIDTH;
        m_ColumnWidths[CERTMGR_SAFER_USER_ENTRIES][COLNUM_SAFER_ENTRIES_LEVEL] = SAFER_ENTRY_LEVEL_WIDTH;
        m_ColumnWidths[CERTMGR_SAFER_USER_ENTRIES][COLNUM_SAFER_ENTRIES_DESCRIPTION] = SAFER_ENTRY_DESCRIPTION_WIDTH;
        m_ColumnWidths[CERTMGR_SAFER_USER_ENTRIES][COLNUM_SAFER_ENTRIES_LAST_MODIFIED_DATE] = SAFER_ENTRY_LAST_MODIFIED_DATE_WIDTH;
    }

	m_ColumnWidths[CERTMGR_SAFER_COMPUTER_LEVEL] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_SAFER_COMPUTER_LEVEL] )
		m_ColumnWidths[CERTMGR_SAFER_COMPUTER_LEVEL][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_SAFER_USER_LEVEL] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_SAFER_USER_LEVEL] )
		m_ColumnWidths[CERTMGR_SAFER_USER_LEVEL][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ENTRY] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ENTRY] )
		m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ENTRY][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_SAFER_USER_ENTRY] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_SAFER_USER_ENTRY] )
		m_ColumnWidths[CERTMGR_SAFER_USER_ENTRY][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_SAFER_COMPUTER_TRUSTED_PUBLISHERS] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_SAFER_COMPUTER_TRUSTED_PUBLISHERS] )
		m_ColumnWidths[CERTMGR_SAFER_COMPUTER_TRUSTED_PUBLISHERS][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_SAFER_USER_TRUSTED_PUBLISHERS] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_SAFER_USER_TRUSTED_PUBLISHERS] )
		m_ColumnWidths[CERTMGR_SAFER_USER_TRUSTED_PUBLISHERS][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_SAFER_COMPUTER_DEFINED_FILE_TYPES] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_SAFER_COMPUTER_DEFINED_FILE_TYPES] )
		m_ColumnWidths[CERTMGR_SAFER_COMPUTER_DEFINED_FILE_TYPES][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_SAFER_USER_DEFINED_FILE_TYPES] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_SAFER_USER_DEFINED_FILE_TYPES] )
		m_ColumnWidths[CERTMGR_SAFER_USER_DEFINED_FILE_TYPES][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_SAFER_USER_ENFORCEMENT] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_SAFER_USER_ENFORCEMENT] )
		m_ColumnWidths[CERTMGR_SAFER_USER_ENFORCEMENT][0] = SINGLE_COL_WIDTH;

	m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ENFORCEMENT] = new UINT[1];
	if ( m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ENFORCEMENT] )
		m_ColumnWidths[CERTMGR_SAFER_COMPUTER_ENFORCEMENT][0] = SINGLE_COL_WIDTH;

	_TRACE (-1, L"Leaving CCertMgrComponent::CCertMgrComponent\n");
}

CCertMgrComponent::~CCertMgrComponent ()
{
	_TRACE (1, L"Entering CCertMgrComponent::~CCertMgrComponent\n");
	VERIFY ( SUCCEEDED (ReleaseAll ()) );

	CloseAndReleaseUsageStores ();

	for (int i = 0; i < CERTMGR_NUMTYPES; i++)
	{
        if ( m_ColumnWidths[i] )
		    delete [] m_ColumnWidths[i];
	}

    if ( m_pLastUsageCookie )
        m_pLastUsageCookie->Release ();

    if ( m_pToolbar )
        m_pToolbar->Release ();

    if ( m_pControlbar )
        m_pControlbar->Release ();

	_TRACE (-1, L"Leaving CCertMgrComponent::~CCertMgrComponent\n");
}

HRESULT CCertMgrComponent::ReleaseAll ()
{
	_TRACE (1, L"Entering CCertMgrComponent::ReleaseAll\n");

	HRESULT hr = CComponent::ReleaseAll ();
	_TRACE (-1, L"Leaving CCertMgrComponent::ReleaseAll: 0x%x\n", hr);
	return hr;
}


/////////////////////////////////////////////////////////////////////////////
// IComponent Implementation

HRESULT CCertMgrComponent::LoadStrings ()
{
	_TRACE (1, L"Entering CCertMgrComponent::LoadStrings\n");
	_TRACE (-1, L"Leaving CCertMgrComponent::LoadStrings\n");
	return S_OK;
}

HRESULT CCertMgrComponent::LoadColumns ( CCertMgrCookie* pcookie )
{
	_TRACE (1, L"Entering CCertMgrComponent::LoadColumns\n");
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
     TEST_NONNULL_PTR_PARAM (pcookie);
	HRESULT	hr = S_OK;
	CString	str;


	switch ( pcookie->m_objecttype )
	{

	case CERTMGR_SNAPIN:
		if ( IDM_STORE_VIEW == QueryComponentDataRef ().m_activeViewPersist )
			VERIFY (str.LoadString (IDS_COLUMN_LOG_CERTIFICATE_STORE) );
		else
			VERIFY (str.LoadString (IDS_COLUMN_PURPOSE) );
		hr = m_pHeader->InsertColumn (0,
				const_cast<LPWSTR> ((LPCWSTR) str), LVCFMT_LEFT, m_ColumnWidths
				[CERTMGR_SNAPIN][0]);
		break;

	case CERTMGR_LOG_STORE:
		if ( QueryComponentDataRef ().m_bShowPhysicalStoresPersist )
			VERIFY (str.LoadString (IDS_COLUMN_PHYS_CERTIFICATE_STORE) );
		else
			VERIFY (str.LoadString (IDS_COLUMN_OBJECT_TYPE) );
		hr = m_pHeader->InsertColumn (0,
				const_cast<LPWSTR> ((LPCWSTR) str), LVCFMT_LEFT,
				m_ColumnWidths[CERTMGR_LOG_STORE][0]);
		break;

	case CERTMGR_LOG_STORE_GPE:
		{
			CCertStoreGPE* pStore = reinterpret_cast <CCertStoreGPE*> (pcookie);
			if ( pStore )
			{
				switch (pStore->GetStoreType ())
				{
				case EFS_STORE:
					if ( pStore->IsNullEFSPolicy () )
					{
						VERIFY (str.LoadString (IDS_STATUS));
						hr = m_pHeader->InsertColumn (0,
								const_cast<LPWSTR> ((LPCWSTR) str), LVCFMT_LEFT,
								SINGLE_COL_WIDTH);
					}
					else
						hr = LoadColumnsFromArrays ( (INT) (CERTMGR_CERT_CONTAINER));
					break;

				case ROOT_STORE:
					hr = LoadColumnsFromArrays ( (INT) (CERTMGR_CERT_CONTAINER));
					break;

				case TRUST_STORE:
					hr = LoadColumnsFromArrays ( (INT) (CERTMGR_CTL_CONTAINER));
					break;

				case ACRS_STORE:
					VERIFY (str.LoadString (IDS_COLUMN_AUTO_CERT_REQUEST));
					hr = m_pHeader->InsertColumn (0,
							const_cast<LPWSTR> ((LPCWSTR) str), LVCFMT_LEFT,
							m_ColumnWidths[CERTMGR_AUTO_CERT_REQUEST][0]);
					break;

				default:
					break;
				}
			}
			else
                {
                     _TRACE (0, L"Unexpected error: reinterpret_cast <CCertStoreGPE*> (pcookie) failed.\n");
                     hr = E_UNEXPECTED;
                }
		}
		break;

	case CERTMGR_LOG_STORE_RSOP:
		{
			CCertStoreRSOP* pStore = reinterpret_cast <CCertStoreRSOP*> (pcookie);
			if ( pStore )
			{
				switch (pStore->GetStoreType ())
				{
				case EFS_STORE:
					if ( pStore->IsNullEFSPolicy () )
					{
						VERIFY (str.LoadString (IDS_STATUS));
						hr = m_pHeader->InsertColumn (0,
								const_cast<LPWSTR> ((LPCWSTR) str), LVCFMT_LEFT,
								SINGLE_COL_WIDTH);
					}
					else
						hr = LoadColumnsFromArrays ( (INT) (CERTMGR_CERT_CONTAINER));
					break;

				case ROOT_STORE:
					hr = LoadColumnsFromArrays ( (INT) (CERTMGR_CERT_CONTAINER));
					break;

				case TRUST_STORE:
					hr = LoadColumnsFromArrays ( (INT) (CERTMGR_CTL_CONTAINER));
					break;

				case ACRS_STORE:
					VERIFY (str.LoadString (IDS_COLUMN_AUTO_CERT_REQUEST));
					hr = m_pHeader->InsertColumn (0,
							const_cast<LPWSTR> ((LPCWSTR) str), LVCFMT_LEFT,
							m_ColumnWidths[CERTMGR_AUTO_CERT_REQUEST][0]);
					break;

				default:
					break;
				}
			}
			else
                {
                     _TRACE (0, L"Unexpected error: reinterpret_cast <CCertStoreGPE*> (pcookie) failed.\n");
                     hr = E_UNEXPECTED;
                }
		}
		break;

	default:
		hr = LoadColumnsFromArrays ( (INT) (pcookie->m_objecttype));
		break;
	}


	_TRACE (-1, L"Leaving CCertMgrComponent::LoadColumns: 0x%x\n", hr);
	return hr;
}


/* This is generated by UpdateAllViews () */
HRESULT CCertMgrComponent::OnViewChange (LPDATAOBJECT pDataObject, LPARAM /*data*/, LPARAM hint)
{
	_TRACE (1, L"Entering CCertMgrComponent::OnViewChange\n");
     HRESULT hr = S_OK;
	if ( pDataObject )
    {
        if ( HINT_CERT_ENROLLED_USAGE_MODE & hint )
        {
            // Force reenumeration of usage stores
            m_bUsageStoresEnumerated = false;
        }

	    if ( (HINT_CHANGE_VIEW_TYPE & hint) ||
		    (HINT_CHANGE_STORE_TYPE & hint) ||
		    (HINT_SHOW_ARCHIVE_CERTS & hint) ||
            (HINT_CHANGE_COMPUTER & hint) ||
            (HINT_REFRESH_STORES & hint) )
        {
		    hr = QueryComponentDataRef ().RefreshScopePane (0);
	    }
	    else if ( HINT_EFS_ADD_DEL_POLICY & hint )
	    {
            // Delete existing columns and add new columns
            if ( m_pResultData )
            {
                m_pResultData->DeleteAllRsltItems ();
            }
            else
            {
                _TRACE (0, L"Unexpected error: m_pResultData was NULL\n");
            }
            do {
                hr = m_pHeader->DeleteColumn (0);
            } while ( SUCCEEDED (hr) );

            CCertMgrCookie* pCookie = ConvertCookie (pDataObject);
            if ( pCookie )
                hr = LoadColumns (pCookie);
            else
            {
                _TRACE (0, L"Unexpected error: ConvertCookie () returned NULL\n");
                hr = E_UNEXPECTED;
            }
        }
        else if ( (HINT_PASTE_COOKIE & hint) ||
                (HINT_IMPORT & hint) )
        {
            // Do nothing
        }
        else
        {
            hr = QueryComponentDataRef ().RefreshScopePane (pDataObject);
            if ( IDM_USAGE_VIEW == QueryComponentDataRef ().m_activeViewPersist && 
                    m_pLastUsageCookie)
            {
                hr = DisplayCertificateCountByUsage (
                        m_pLastUsageCookie->GetObjectName (),
                        m_pLastUsageCookie->GetCertCount ());
            }
        }

        if ( SUCCEEDED (hr) )
        {
            hr = RefreshResultPane ();
        }

        CCertMgrComponentData&	compData = QueryComponentDataRef ();
        CCertMgrCookie* pCookie = compData.ConvertCookie (pDataObject);
        if ( pCookie )
        {
            switch (pCookie->m_objecttype)
            {
            case CERTMGR_CERTIFICATE:
                {
                    CCertificate* pCert = reinterpret_cast <CCertificate*> (pCookie);
                    if ( pCert )
                    {
                        if ( IDM_STORE_VIEW == QueryComponentDataRef ().m_activeViewPersist )
                        {
                            hr = DisplayCertificateCountByStore (m_pConsole, 
                                    pCert->GetCertStore ());
                        }
                        else
                        {
                            ASSERT (m_pLastUsageCookie);
                            if ( m_pLastUsageCookie )
                            {
                                 hr = DisplayCertificateCountByUsage (
                                        m_pLastUsageCookie->GetObjectName (),
                                        m_pLastUsageCookie->GetCertCount ());
                            }
                        }
                    }
                }
                break;

            case CERTMGR_LOG_STORE:
            case CERTMGR_PHYS_STORE:
            case CERTMGR_LOG_STORE_GPE:
            case CERTMGR_LOG_STORE_RSOP:
                {
                    CCertStore* pStore = reinterpret_cast <CCertStore*> (pCookie);
                    if ( pStore )
                    {
                        pStore->GetStoreHandle (); // to initialize read-only flag
                        if ( pStore->IsReadOnly () )
                            m_pConsoleVerb->SetVerbState (MMC_VERB_PASTE, ENABLED, FALSE);
                        else
                            m_pConsoleVerb->SetVerbState (MMC_VERB_PASTE, ENABLED, TRUE);
                        hr = DisplayCertificateCountByStore (m_pConsole, pStore,
                                (CERTMGR_LOG_STORE_GPE == pCookie->m_objecttype || 
                                CERTMGR_LOG_STORE_RSOP == pCookie->m_objecttype));
                        pStore->Close ();
                    }
                    else
                        hr = E_UNEXPECTED;
                }
                break;

            case CERTMGR_USAGE:
                {
                    CUsageCookie* pUsage = reinterpret_cast <CUsageCookie*> (pCookie);
                    if ( pUsage )
                    {
                        hr = DisplayCertificateCountByUsage (pCookie->GetObjectName (),
                        pUsage->GetCertCount ());
                    }
                    else
                        hr = E_UNEXPECTED;
                }
                break;

            case CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS:
            case CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS:
                ASSERT (0);
                break;

            case CERTMGR_SNAPIN:
            case CERTMGR_CRL_CONTAINER:
            case CERTMGR_CTL_CONTAINER:
            case CERTMGR_CERT_CONTAINER:
            case CERTMGR_CRL:
            case CERTMGR_CTL:
            case CERTMGR_AUTO_CERT_REQUEST:
            case CERTMGR_CERT_POLICIES_USER:
            case CERTMGR_CERT_POLICIES_COMPUTER:
            default:
                {
                    IConsole2*	pConsole2 = 0;
                    hr = m_pConsole->QueryInterface (
                            IID_PPV_ARG(IConsole2, &pConsole2));
                    if (SUCCEEDED (hr))
                    {
                        hr = pConsole2->SetStatusText (L"");
                        if ( !SUCCEEDED (hr) )
                        {
                            _TRACE (0, L"IConsole2::SetStatusText () failed: %x", hr);
                        }
                        pConsole2->Release ();
                    }
                }
                break;
            }
        }
    }
    else
    {
        hr = E_POINTER;
        _TRACE (0, L"Unexpected error: paramater pDataObject was NULL\n");
    }

    _TRACE (-1, L"Leaving CCertMgrComponent::OnViewChange: 0x%x\n", hr);
    return hr;
}

HRESULT CCertMgrComponent::Show ( CCookie* pcookie, LPARAM arg, HSCOPEITEM /*hScopeItem*/, LPDATAOBJECT /*pDataObject*/)
{
	_TRACE (1, L"Entering CCertMgrComponent::Show\n");
	HRESULT	hr = S_OK;
     TEST_NONNULL_PTR_PARAM (pcookie);

	if ( !arg )
	{
		if ( !m_pResultData )
		{
			_TRACE (0, L"Unexpected error: m_pResultData was NULL\n");
			return E_UNEXPECTED;
		}

		m_pViewedCookie = reinterpret_cast <CCertMgrCookie*> (pcookie);
		if ( m_pViewedCookie )
			hr = SaveWidths (m_pViewedCookie);
		m_pViewedCookie = 0;
		return S_OK;
	}

    if ( m_pResultData )
    {
        m_pResultData->ModifyViewStyle (MMC_ENSUREFOCUSVISIBLE, 
                (MMC_RESULT_VIEW_STYLE) 0);
    }

	m_pViewedCookie = reinterpret_cast <CCertMgrCookie*> (pcookie);
     if ( m_pViewedCookie )
	{
		// Load default columns and widths
		LoadColumns (m_pViewedCookie);

		// Restore persisted column widths
		switch (m_pViewedCookie->m_objecttype)
		{
		case CERTMGR_SNAPIN:
		case CERTMGR_USAGE:
		case CERTMGR_PHYS_STORE:
		case CERTMGR_LOG_STORE:
		case CERTMGR_CRL_CONTAINER:
		case CERTMGR_CTL_CONTAINER:
		case CERTMGR_CERT_CONTAINER:
		case CERTMGR_LOG_STORE_GPE:
		case CERTMGR_LOG_STORE_RSOP:
		case CERTMGR_CERT_POLICIES_USER:
		case CERTMGR_CERT_POLICIES_COMPUTER:
        case CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS:
        case CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS:
            break;

        case CERTMGR_CERTIFICATE:
		case CERTMGR_CRL:
		case CERTMGR_CTL:
		case CERTMGR_AUTO_CERT_REQUEST:
		default:
			_TRACE (0, L"Invalid or unexpected m_objecttype in switch: 0x%x\n", m_pViewedCookie->m_objecttype);
			break;
		}

		hr = PopulateListbox (m_pViewedCookie);
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::Show: 0x%x\n", hr);
	return hr;
}

HRESULT CCertMgrComponent::Show ( CCookie* pcookie, LPARAM arg, HSCOPEITEM hScopeItem)
{
	_TRACE (1, L"Entering CCertMgrComponent::Show\n");
	_TRACE (0, L"Unexpected: We should never enter this method.\n");
	_TRACE (-1, L"Leaving CCertMgrComponent::Show\n");
	return Show (pcookie, arg, hScopeItem, 0);
}


HRESULT CCertMgrComponent::OnNotifyAddImages (
        LPDATAOBJECT /*pDataObject*/,
        LPIMAGELIST lpImageList,
        HSCOPEITEM /*hSelectedItem*/)
{
	_TRACE (1, L"Entering CCertMgrComponent::OnNotifyAddImages\n");
	long	lViewMode = 0;
     HRESULT hr = S_OK;

	if ( m_pResultData )
     {
	     QueryComponentDataRef ().SetResultData (m_pResultData);

	     hr = m_pResultData->GetViewMode (&lViewMode);	
	     if ( SUCCEEDED (hr) )
         {
	        BOOL	bLoadLargeIcons = (LVS_ICON == lViewMode);

	        hr = QueryComponentDataRef ().LoadIcons (lpImageList, bLoadLargeIcons);
         }
     }
     else
     {
          _TRACE (0, L"Unexpected error: m_pResultData is NULL\n");
          hr = E_UNEXPECTED;
     }
	_TRACE (-1, L"Leaving CCertMgrComponent::OnNotifyAddImages: 0x%x\n", hr);
	return hr;
}

HRESULT CCertMgrComponent::EnumCertificates (CCertStore& rCertStore)
{
	_TRACE (1, L"Entering CCertMgrComponent::EnumCertificates\n");

	CWaitCursor				cursor;
     PCCERT_CONTEXT			pCertContext = 0;
	HRESULT					hr = 0;
	CCertificate*			pCert = 0;
	RESULTDATAITEM			rdItem;
	CCookie&				rootCookie = QueryComponentDataRef ().QueryBaseRootCookie ();

	::ZeroMemory (&rdItem, sizeof (rdItem));
	rdItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM;
	rdItem.nImage = iIconCertificate;
	rdItem.nCol = 0;
	rdItem.str = MMC_TEXTCALLBACK;


	//	Iterate through the list of certificates in the system store,
	//	allocate new certificates with the CERT_CONTEXT returned,
	//	and store them in the certificate list.
	while ( 1 )
	{
		pCertContext = rCertStore.EnumCertificates (pCertContext);
		if ( !pCertContext )
		{
			if ( EFS_STORE == rCertStore.GetStoreType () )
			{
				if ( rCertStore.IsNullEFSPolicy () )
				{
					CString	name;
					VERIFY (name.LoadString (IDS_NO_POLICY_DEFINED));
					CCertMgrCookie* pNewCookie = new CCertMgrCookie (
							CERTMGR_NULL_POLICY, 0, (LPCWSTR) name);
					if ( pNewCookie )
					{
						rootCookie.m_listResultCookieBlocks.AddHead (pNewCookie);
						::ZeroMemory (&rdItem, sizeof (rdItem));
						rdItem.mask = RDI_STR | RDI_PARAM;
                        rdItem.str = MMC_TEXTCALLBACK;
						rdItem.lParam = (LPARAM) pNewCookie;
						pNewCookie->m_resultDataID = m_pResultData;
						hr = m_pResultData->InsertItem (&rdItem);
					}
					else
					{
						hr = E_OUTOFMEMORY;
						break;
					}
				}
			}
			break;
		}
		pCert =
			new CCertificate (pCertContext, &rCertStore);
		if ( !pCert )
		{
			hr = E_OUTOFMEMORY;
			break;
		}

		rootCookie.m_listResultCookieBlocks.AddHead (pCert);
		rdItem.lParam = (LPARAM) pCert;
		pCert->m_resultDataID = m_pResultData;
		hr = m_pResultData->InsertItem (&rdItem);
          if ( FAILED (hr) )
          {
		     _TRACE (0, L"IResultData::InsertItem () failed: 0x%x\n", hr);
          }
	}
	rCertStore.Close ();

	_TRACE (-1, L"Leaving CCertMgrComponent::EnumCertificates: 0x%x\n", hr);
	return hr;
}

HRESULT CCertMgrComponent::PopulateListbox (CCertMgrCookie* pCookie)
{
	_TRACE (1, L"Entering CCertMgrComponent::PopulateListbox\n");
    if ( !pCookie )
        return E_POINTER;

	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	HRESULT		hr = S_OK;
	CWaitCursor	cursor;
    CCertMgrComponentData& dataRef = QueryComponentDataRef ();

	switch ( pCookie->m_objecttype )
	{
	case CERTMGR_PHYS_STORE:
	case CERTMGR_LOG_STORE:
		break;

	case CERTMGR_LOG_STORE_GPE:
	case CERTMGR_LOG_STORE_RSOP:
		{
			CCertStore*	pStore = reinterpret_cast <CCertStore*> (pCookie);
			if ( pStore )
			{
				switch (pStore->GetStoreType () )
				{
				case EFS_STORE:
				case ROOT_STORE:
					hr = EnumCertificates (*pStore);
					if ( SUCCEEDED (hr) )
					{
						m_currResultNodeType = CERTMGR_CERTIFICATE;
						m_pResultData->Sort (m_nSelectedCertColumn, 0, 
                                (long) m_currResultNodeType);
					}
					break;

				case ACRS_STORE:
					hr = EnumCTLs (*pStore);
					if ( SUCCEEDED (hr) )
					{
						m_currResultNodeType = CERTMGR_AUTO_CERT_REQUEST;
						m_pResultData->Sort (m_nSelectedCTLColumn, 0, 
                                (long) m_currResultNodeType);
					}
					break;

				case TRUST_STORE:
					hr = EnumCTLs (*pStore);
					if ( SUCCEEDED (hr) )
					{
						m_currResultNodeType = CERTMGR_CTL;
						m_pResultData->Sort (m_nSelectedCTLColumn, 0, 
                                (long) m_currResultNodeType);
					}
					break;


				default:
				     _TRACE (0, L"Error: Unexpected store type: 0x%x\n", pStore->GetStoreType ());
                          hr = E_UNEXPECTED;
					break;
				}

                if ( SUCCEEDED (hr) )
                    hr = DisplayCertificateCountByStore (m_pConsole, pStore, true);
			}
			else
				hr = E_POINTER;
		}
		break;

	case CERTMGR_CERT_CONTAINER:
		{
			CContainerCookie*	pContainer = reinterpret_cast <CContainerCookie*> (pCookie);
			if ( pContainer )
			{
				hr = EnumCertificates (pContainer->GetCertStore ());
				if ( SUCCEEDED (hr) )
				{
					m_currResultNodeType = CERTMGR_CERTIFICATE;
					m_pResultData->Sort (m_nSelectedCertColumn, 0, 
                            (long) m_currResultNodeType);
                    hr = DisplayCertificateCountByStore (m_pConsole, &pContainer->GetCertStore (), false);
				}
			}
		}
		break;

	case CERTMGR_USAGE:
		{
			CUsageCookie* pUsageCookie = reinterpret_cast <CUsageCookie*> (pCookie);
			if ( pUsageCookie )
			{
				hr = EnumCertsByUsage (pUsageCookie);
				if ( SUCCEEDED (hr) )
				{
					m_currResultNodeType = CERTMGR_CERTIFICATE;
					m_pResultData->Sort (m_nSelectedCertColumn, 0, 
                            (long) m_currResultNodeType);
				}
			}
		}
		break;

	case CERTMGR_CRL_CONTAINER:
		{
			CContainerCookie*	pContainer = reinterpret_cast <CContainerCookie*> (pCookie);
			if ( pContainer )
			{
				PCCRL_CONTEXT	pCRLContext = 0;
				CCRL*			pCRL = 0;
				RESULTDATAITEM	rdItem;
				CCookie&		rootCookie = dataRef.QueryBaseRootCookie ();


				::ZeroMemory (&rdItem, sizeof (rdItem));
				rdItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM;
				rdItem.nImage = iIconCRL;
				rdItem.nCol = 0;

				//	Iterate through the list of certificates in the system store,
				//	allocate new certificates with the CERT_CONTEXT returned,
				//	and store them in the certificate list.
				DWORD	dwFlags = 0;
				while ( 1 )
				{
					pCRLContext = pContainer->GetCertStore ().GetCRL (NULL,
							pCRLContext, &dwFlags);
					if ( !pCRLContext )
						break;
					pCRL =
						new CCRL (pCRLContext, pContainer->GetCertStore ());
					if ( !pCRL )
					{
						hr = E_OUTOFMEMORY;
						break;
					}

					rootCookie.m_listResultCookieBlocks.AddHead (pCRL);
					rdItem.str = MMC_TEXTCALLBACK;
					rdItem.lParam = (LPARAM) pCRL;
					pCRL->m_resultDataID = m_pResultData;
					hr = m_pResultData->InsertItem (&rdItem);
                          if ( FAILED (hr) )
                          {
		                     _TRACE (0, L"IResultData::InsertItem () failed: 0x%x\n", hr);
                          }
				}
				if ( SUCCEEDED (hr) )
				{
					m_currResultNodeType = CERTMGR_CRL;
					m_pResultData->Sort (m_nSelectedCRLColumn, 0, 
                            (long) m_currResultNodeType);
				}
			}
		}
		break;

	case CERTMGR_CTL_CONTAINER:
		{
			CContainerCookie*	pContainer = reinterpret_cast <CContainerCookie*> (pCookie);
			if ( pContainer )
			{
				hr = EnumCTLs (pContainer->GetCertStore ());
				if ( SUCCEEDED (hr) )
				{
					m_currResultNodeType = CERTMGR_CTL;
					m_pResultData->Sort (m_nSelectedCTLColumn, 0, 
                            (long) m_currResultNodeType);
                    hr = DisplayCertificateCountByStore (m_pConsole, &pContainer->GetCertStore (), false);
				}
			}
		}
		break;


    case CERTMGR_CERT_POLICIES_USER:
    case CERTMGR_CERT_POLICIES_COMPUTER:
        // Only this node if machine is joined to a Whistler or later domain
        if ( !dataRef.m_bMachineIsStandAlone && !g_bSchemaIsW2K )
		{
			RESULTDATAITEM	rdItem;
			CCookie&		rootCookie = dataRef.QueryBaseRootCookie ();


			::ZeroMemory (&rdItem, sizeof (rdItem));
			rdItem.mask = RDI_STR | RDI_PARAM | RDI_IMAGE;
			rdItem.nImage = iIconAutoEnroll;
			rdItem.nCol = 0;

            CString objectName;
            VERIFY (objectName.LoadString (IDS_PKP_AUTOENROLLMENT_SETTINGS));
            CCertMgrCookie* pNewCookie = new CCertMgrCookie (
                    CERTMGR_CERT_POLICIES_COMPUTER == pCookie->m_objecttype ? 
                        CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS :
                        CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS,
                    pCookie->QueryNonNULLMachineName (),
                    objectName);
			if ( !pNewCookie )
			{
				hr = E_OUTOFMEMORY;
				break;
			}

			rootCookie.m_listResultCookieBlocks.AddHead (pNewCookie);
			rdItem.str = MMC_TEXTCALLBACK ;
			rdItem.lParam = (LPARAM) pNewCookie;
			pNewCookie->m_resultDataID = m_pResultData;
			hr = m_pResultData->InsertItem (&rdItem);
            if ( FAILED (hr) )
            {
                 _TRACE (0, L"IResultData::InsertItem () failed: 0x%x\n", hr);
            }
		}
		break;

    case CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS:
    case CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS:
        ASSERT (0);
        break;

    case CERTMGR_SAFER_COMPUTER_LEVELS:
        {
            CPolicyKey  policyKey (dataRef.m_pGPEInformation, 
                    SAFER_HKLM_REGBASE, true);
            hr = AddSaferLevels (true, 
                    pCookie->QueryNonNULLMachineName (), policyKey.GetKey ());
        }
        break;

    case CERTMGR_SAFER_USER_LEVELS:
        {
            CPolicyKey  policyKey (dataRef.m_pGPEInformation, 
                    SAFER_HKLM_REGBASE, false);
            hr = AddSaferLevels (false, 
                    pCookie->QueryNonNULLMachineName (), policyKey.GetKey ());
        }
        break;

    case CERTMGR_SAFER_COMPUTER_ENTRIES:
    case CERTMGR_SAFER_USER_ENTRIES:
        {
            CSaferEntries* pSaferEntries = dynamic_cast <CSaferEntries*> (pCookie);
            if ( pSaferEntries )
            {
                hr = SaferEnumerateEntries (
                        CERTMGR_SAFER_COMPUTER_ENTRIES == pCookie->m_objecttype,
                        pSaferEntries);
                if (SUCCEEDED (hr) )
                    m_pResultData->Sort (m_nSelectedCertColumn, 0, 
                            (long) m_currResultNodeType);
            }
        }
        break;

    case CERTMGR_SAFER_COMPUTER_ROOT:
    case CERTMGR_SAFER_USER_ROOT:
        {
            CSaferRootCookie* pSaferRootCookie = dynamic_cast <CSaferRootCookie*> (pCookie);
            if ( pSaferRootCookie )
            {
                if ( (pSaferRootCookie->m_bCreateSaferNodes && dataRef.m_bSaferSupported) 
                        || dataRef.m_bIsRSOP )
		        {
			        RESULTDATAITEM	rdItem;
			        CCookie&		rootCookie = dataRef.QueryBaseRootCookie ();


			        ::ZeroMemory (&rdItem, sizeof (rdItem));
			        rdItem.mask = RDI_STR | RDI_PARAM | RDI_IMAGE;
			        rdItem.nImage = iIconSettings;
			        rdItem.nCol = 0;

                    CString         objectName;
                    CCertMgrCookie* pNewCookie = 0;

                    if ( SUCCEEDED (hr) )
                    {
                        VERIFY (objectName.LoadString (IDS_SAFER_ENFORCEMENT));
                        pNewCookie = new CCertMgrCookie (
                                CERTMGR_SAFER_COMPUTER_ROOT == pCookie->m_objecttype ? 
                                    CERTMGR_SAFER_COMPUTER_ENFORCEMENT :
                                    CERTMGR_SAFER_USER_ENFORCEMENT,
                                pCookie->QueryNonNULLMachineName (),
                                objectName);
			            if ( !pNewCookie )
			            {
				            hr = E_OUTOFMEMORY;
				            break;
			            }

			            rootCookie.m_listResultCookieBlocks.AddHead (pNewCookie);
			            rdItem.str = MMC_TEXTCALLBACK ;
			            rdItem.lParam = (LPARAM) pNewCookie;
			            pNewCookie->m_resultDataID = m_pResultData;
			            hr = m_pResultData->InsertItem (&rdItem);
                        if ( FAILED (hr) )
                        {
                             _TRACE (0, L"IResultData::InsertItem () failed: 0x%x\n", hr);
                        }
                    }

                    if ( SUCCEEDED (hr) )
                    {
                        VERIFY (objectName.LoadString (IDS_SAFER_DEFINED_FILE_TYPES));
                        pNewCookie = new CCertMgrCookie (
                                CERTMGR_SAFER_COMPUTER_ROOT == pCookie->m_objecttype ? 
                                    CERTMGR_SAFER_COMPUTER_DEFINED_FILE_TYPES :
                                    CERTMGR_SAFER_USER_DEFINED_FILE_TYPES,
                                pCookie->QueryNonNULLMachineName (),
                                objectName);
			            if ( !pNewCookie )
			            {
				            hr = E_OUTOFMEMORY;
				            break;
			            }

			            rootCookie.m_listResultCookieBlocks.AddHead (pNewCookie);

			            rdItem.str = MMC_TEXTCALLBACK ;
			            rdItem.lParam = (LPARAM) pNewCookie;
			            pNewCookie->m_resultDataID = m_pResultData;
			            hr = m_pResultData->InsertItem (&rdItem);
                        if ( FAILED (hr) )
                        {
                             _TRACE (0, L"IResultData::InsertItem () failed: 0x%x\n", hr);
                        }
                    }

                    if ( SUCCEEDED (hr) )
                    {
                        VERIFY (objectName.LoadString (IDS_SAFER_TRUSTED_PUBLISHERS));
                        pNewCookie = new CCertMgrCookie (
                                CERTMGR_SAFER_COMPUTER_ROOT == pCookie->m_objecttype ? 
                                    CERTMGR_SAFER_COMPUTER_TRUSTED_PUBLISHERS :
                                    CERTMGR_SAFER_USER_TRUSTED_PUBLISHERS,
                                pCookie->QueryNonNULLMachineName (),
                                objectName);
			            if ( !pNewCookie )
			            {
				            hr = E_OUTOFMEMORY;
				            break;
			            }

			            rootCookie.m_listResultCookieBlocks.AddHead (pNewCookie);

			            rdItem.str = MMC_TEXTCALLBACK ;
			            rdItem.lParam = (LPARAM) pNewCookie;
			            pNewCookie->m_resultDataID = m_pResultData;
			            hr = m_pResultData->InsertItem (&rdItem);
                        if ( FAILED (hr) )
                        {
                             _TRACE (0, L"IResultData::InsertItem () failed: 0x%x\n", hr);
                        }
                    }
		        }
                else
                {
                    CComPtr<IUnknown> spUnknown;
                    hr = m_pConsole->QueryResultView(&spUnknown);
                    if ( SUCCEEDED (hr) )
                    {
                        CComPtr<IMessageView> spMessageView;
                        hr = spUnknown->QueryInterface (IID_PPV_ARG (IMessageView, &spMessageView));
                        if (SUCCEEDED(hr))
                        {
                            CString szTitle;
                            CString szMessage;

                            VERIFY (szTitle.LoadString (IDS_SAFER_NO_POLICY_TITLE));
                            VERIFY (szMessage.LoadString (IDS_SAFER_NO_POLICY_TEXT));

                            spMessageView->SetTitleText (szTitle);
                            spMessageView->SetBodyText (szMessage);
                            spMessageView->SetIcon (Icon_Warning);
                        }
                    }
                }
            }
        }
		break;

	default:
		break;
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::PopulateListbox: 0x%x\n", hr);
	return hr;
}

HRESULT CCertMgrComponent::RefreshResultPane ()
{
	_TRACE (1, L"Entering CCertMgrComponent::RefreshResultPane\n");
	HRESULT hr = S_OK;

	if ( m_pResultData )
	{
		// Does this return E_UNEXPECTED when there are no items?
		HRESULT hr1 = m_pResultData->DeleteAllRsltItems ();
		if ( FAILED (hr1) )
		{
               _TRACE (0, L"IResultData::DeleteAllRsltItems () failed: 0x%x\n", hr1);
		}
	}
	else
     {
          _TRACE (0, L"Unexpected error: m_pResultData is NULL\n");
		hr = E_UNEXPECTED;
     }

	if ( m_pViewedCookie )
	{
		hr = PopulateListbox (m_pViewedCookie);
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::RefreshResultPane: 0x%x\n", hr);
	return hr;
}

STDMETHODIMP CCertMgrComponent::GetDisplayInfo (RESULTDATAITEM * pResult)
{	
//	_TRACE (1, L"Entering CCertMgrComponent::GetDisplayInfo\n");
	AFX_MANAGE_STATE (AfxGetStaticModuleState ());
	HRESULT hr = S_OK;


	if ( pResult && !pResult->bScopeItem ) //&& (pResult->mask & RDI_PARAM) )
	{
		CCookie* pResultCookie = reinterpret_cast<CCookie*> (pResult->lParam);
		ASSERT (pResultCookie);
		if ( !pResultCookie || IsBadWritePtr ((LPVOID) pResultCookie, sizeof (CCookie)) )
			return E_UNEXPECTED;

		CCookie* pActiveCookie = ActiveBaseCookie (pResultCookie);
		ASSERT (pActiveCookie);
		if ( !pActiveCookie || IsBadWritePtr ((LPVOID) pActiveCookie, sizeof (CCookie)) )
			return E_UNEXPECTED;

		CCertMgrCookie* pCookie = reinterpret_cast <CCertMgrCookie*>(pActiveCookie);
		ASSERT (pCookie);
		switch (pCookie->m_objecttype)
		{
        case CERTMGR_SAFER_COMPUTER_LEVELS:
        case CERTMGR_SAFER_COMPUTER_ENTRIES:
        case CERTMGR_SAFER_USER_LEVELS:
        case CERTMGR_SAFER_USER_ENTRIES:
            // iIconSaferHashEntry
            // iIconSaferURLEntry
            // iIconSaferNameEntry
            ASSERT (0);
            break;

        case CERTMGR_SAFER_COMPUTER_LEVEL:
        case CERTMGR_SAFER_USER_LEVEL:
			if (pResult->mask & RDI_STR)
			{
				if ( COLNUM_SAFER_LEVEL_NAME == pResult->nCol )
				{
					m_szDisplayInfoResult = pCookie->GetObjectName ();
					pResult->str = const_cast<LPWSTR> ( (LPCWSTR) m_szDisplayInfoResult);
				}
                else if ( COLNUM_SAFER_LEVEL_DESCRIPTION == pResult->nCol )
                {
                    CSaferLevel* pLevel = dynamic_cast <CSaferLevel*> (pCookie);
                    if ( pLevel )
                    {
					    m_szDisplayInfoResult = pLevel->GetDescription ();
					    pResult->str = const_cast<LPWSTR> ( (LPCWSTR) m_szDisplayInfoResult);
                    }
                }
			}
            if ( pResult->mask & RDI_IMAGE )
            {
                CSaferLevel* pLevel = dynamic_cast <CSaferLevel*> (pCookie);
                if ( pLevel && pLevel->IsDefault () )
                {
                    QueryComponentDataRef ().m_dwDefaultSaferLevel = 
                            pLevel->GetLevel ();
                    pResult->nImage = iIconDefaultSaferLevel;
                }
                else
                    pResult->nImage = iIconSaferLevel;
            }
            break;

        case CERTMGR_SAFER_COMPUTER_ENTRY:
        case CERTMGR_SAFER_USER_ENTRY:
            if (pResult->mask & RDI_STR)
            {
                CSaferEntry* pSaferEntry = dynamic_cast <CSaferEntry*> (pCookie);
                if ( pSaferEntry )
                {
			        switch (pResult->nCol)
                    {
                    case COLNUM_SAFER_ENTRIES_NAME:
                        m_szDisplayInfoResult = pSaferEntry->GetDisplayName ();
                        pResult->str = const_cast<LPWSTR> ( (LPCWSTR) m_szDisplayInfoResult);
                        break;

                    case COLNUM_SAFER_ENTRIES_TYPE:
                        m_szDisplayInfoResult = pSaferEntry->GetTypeString ();
                        pResult->str = const_cast<LPWSTR> ( (LPCWSTR) m_szDisplayInfoResult);
                        break;

                    case COLNUM_SAFER_ENTRIES_LEVEL:
                        m_szDisplayInfoResult = pSaferEntry->GetLevelFriendlyName ();
                        pResult->str = const_cast<LPWSTR> ( (LPCWSTR) m_szDisplayInfoResult);
                        break;

                    case COLNUM_SAFER_ENTRIES_DESCRIPTION:
                        m_szDisplayInfoResult = pSaferEntry->GetDescription ();
                        pResult->str = const_cast<LPWSTR> ( (LPCWSTR) m_szDisplayInfoResult);
                        break;

                    case COLNUM_SAFER_ENTRIES_LAST_MODIFIED_DATE:
                        m_szDisplayInfoResult = pSaferEntry->GetShortLastModified ();
                        pResult->str = const_cast<LPWSTR> ( (LPCWSTR) m_szDisplayInfoResult);
                        break;

                    default:
                        ASSERT (0);
                        break;
                    }
                }
            }
            if ( pResult->mask & RDI_IMAGE )
            {
                CSaferEntry* pEntry = dynamic_cast <CSaferEntry*> (pCookie);
                if ( pEntry )
                {
                    switch (pEntry->GetType () )
                    {
                    case SAFER_ENTRY_TYPE_HASH:
                        pResult->nImage = iIconSaferHashEntry;
                        break;

                    case SAFER_ENTRY_TYPE_PATH:
                        pResult->nImage = iIconSaferNameEntry;
                        break;

                    case SAFER_ENTRY_TYPE_URLZONE:
                        pResult->nImage = iIconSaferURLEntry;
                        break;

                    case SAFER_ENTRY_TYPE_CERT:
                        pResult->nImage = iIconSaferCertEntry;
                        break;

                    default:
                        ASSERT (0);
                        break;
                    }
                }
            }
			break;


        case CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS:
        case CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS:
			if (pResult->mask & RDI_STR)
			{
				if ( 0 == pResult->nCol )
				{
					m_szDisplayInfoResult = pCookie->GetObjectName ();
					pResult->str = const_cast<LPWSTR> ( (LPCWSTR) m_szDisplayInfoResult);
				}
			}
			if (pResult->mask & RDI_IMAGE)
                pResult->nImage = iIconAutoEnroll;
			break;

        case CERTMGR_SAFER_COMPUTER_TRUSTED_PUBLISHERS:
        case CERTMGR_SAFER_USER_TRUSTED_PUBLISHERS:
        case CERTMGR_SAFER_COMPUTER_DEFINED_FILE_TYPES:
        case CERTMGR_SAFER_USER_DEFINED_FILE_TYPES:
        case CERTMGR_SAFER_COMPUTER_ENFORCEMENT:
        case CERTMGR_SAFER_USER_ENFORCEMENT:
			if (pResult->mask & RDI_STR)
			{
				if ( 0 == pResult->nCol )
				{
					m_szDisplayInfoResult = pCookie->GetObjectName ();
					pResult->str = const_cast<LPWSTR> ( (LPCWSTR) m_szDisplayInfoResult);
				}
			}
			if (pResult->mask & RDI_IMAGE)
                pResult->nImage = iIconSettings;
			break;

		case CERTMGR_NULL_POLICY:
			if (pResult->mask & RDI_STR)
			{
				if ( 0 == pResult->nCol )
				{
					m_szDisplayInfoResult = pCookie->GetObjectName ();
					pResult->str = const_cast<LPWSTR> ( (LPCWSTR) m_szDisplayInfoResult);
				}
			}
			break;

		case CERTMGR_CERTIFICATE:
			{
				CCertificate* pCert = reinterpret_cast <CCertificate*> (pCookie);
				ASSERT (pCert);
				if ( pCert )
				{
					if (pResult->mask & RDI_STR)
					{
						// Note:  text is first stored in class variable so that the buffer is
						// somewhat persistent.  Copying the buffer pointer directly to the
						// pResult->str would result in the buffer being freed before the pointer
						// is used.
						switch (pResult->nCol)
						{
						case COLNUM_CERT_ISSUER:
							m_szDisplayInfoResult = pCert->GetIssuerName ();
							if ( m_szDisplayInfoResult.IsEmpty () )
							{
								m_szDisplayInfoResult = pCert->GetAlternateIssuerName ();
								if ( m_szDisplayInfoResult.IsEmpty () )
									SetTextNotAvailable ();
							}
							break;

						case COLNUM_CERT_SUBJECT:
							m_szDisplayInfoResult = pCert->GetSubjectName ();
							if ( m_szDisplayInfoResult.IsEmpty () )
							{
								m_szDisplayInfoResult = pCert->GetAlternateSubjectName ();
								if ( m_szDisplayInfoResult.IsEmpty () )
									SetTextNotAvailable ();
							}
							break;

						case COLNUM_CERT_EXPIRATION_DATE:
							m_szDisplayInfoResult = pCert->GetValidNotAfter ();
							break;

						case COLNUM_CERT_PURPOSE:
							m_szDisplayInfoResult = pCert->GetEnhancedKeyUsage ();
							break;

						case COLNUM_CERT_CERT_NAME:
							m_szDisplayInfoResult = pCert->GetFriendlyName ();
							break;

						case COLNUM_CERT_STATUS:
                            m_szDisplayInfoResult = pCert->FormatStatus ();
							break;

                        // NTRAID# 247237	Cert UI: Cert Snapin: Certificates snapin should show  template name
                        case COLNUM_CERT_TEMPLATE:
                            m_szDisplayInfoResult = pCert->GetTemplateName ();
							break;

						default:
							ASSERT (0);
							break;
						}

						pResult->str = const_cast<LPWSTR> ( (LPCWSTR) m_szDisplayInfoResult);
					}
					if (pResult->mask & RDI_IMAGE)
						pResult->nImage = iIconCertificate;
				}
			}
			break;

		case CERTMGR_CTL:
			{
				CCTL* pCTL = reinterpret_cast <CCTL*> (pCookie);
				ASSERT (pCTL);
				if ( pCTL )
				{
					if (pResult->mask & RDI_STR)
					{
						// Note:  text is first stored in class variable so that the buffer is
						// somewhat persistent.  Copying the buffer pointer directly to the
						// pResult->str would result in the buffer being freed before the pointer
						// is used.
						switch (pResult->nCol)
						{
						case COLNUM_CTL_ISSUER:
							m_szDisplayInfoResult = pCTL->GetIssuerName ();
							if ( m_szDisplayInfoResult.IsEmpty () )
							{
								SetTextNotAvailable ();
							}
							break;


						case COLNUM_CTL_EFFECTIVE_DATE:
							m_szDisplayInfoResult = pCTL->GetEffectiveDate ();
							if ( m_szDisplayInfoResult.IsEmpty () )
							{
								SetTextNotAvailable ();
							}
							break;

						case COLNUM_CTL_PURPOSE:
							m_szDisplayInfoResult = pCTL->GetPurpose ();
							if ( m_szDisplayInfoResult.IsEmpty () )
							{
								SetTextNotAvailable ();
							}
							break;

						case COLNUM_CTL_FRIENDLY_NAME:
							m_szDisplayInfoResult = pCTL->GetFriendlyName ();
							if ( m_szDisplayInfoResult.IsEmpty () )
							{
								SetTextNotAvailable ();
							}
							break;

						default:
							ASSERT (0);
							break;
						}

						pResult->str = const_cast<LPWSTR> ( (LPCWSTR) m_szDisplayInfoResult);
					}
					if (pResult->mask & RDI_IMAGE)
						pResult->nImage = iIconCTL;
				}
			}
			break;

		case CERTMGR_CRL:
			{
				CCRL* pCRL = reinterpret_cast <CCRL*> (pCookie);
				ASSERT (pCRL);
				if ( pCRL )
				{
					if (pResult->mask & RDI_STR)
					{
						// Note:  text is first stored in class variable so that the buffer is
						// somewhat persistent.  Copying the buffer pointer directly to the
						// pResult->str would result in the buffer being freed before the pointer
						// is used.
						switch (pResult->nCol)
						{
						case COLNUM_CRL_ISSUER:
							m_szDisplayInfoResult = pCRL->GetIssuerName ();
							if ( m_szDisplayInfoResult.IsEmpty () )
							{
								SetTextNotAvailable ();
							}
							break;


						case COLNUM_CRL_EFFECTIVE_DATE:
							m_szDisplayInfoResult = pCRL->GetEffectiveDate ();
							if ( m_szDisplayInfoResult.IsEmpty () )
							{
								SetTextNotAvailable ();
							}
							break;

						case COLNUM_CRL_NEXT_UPDATE:
							m_szDisplayInfoResult = pCRL->GetNextUpdate ();
							if ( m_szDisplayInfoResult.IsEmpty () )
							{
								SetTextNotAvailable ();
							}
							break;

						default:
							ASSERT (0);
							break;
						}

						pResult->str = const_cast<LPWSTR> ( (LPCWSTR) m_szDisplayInfoResult);
					}
					if (pResult->mask & RDI_IMAGE)
						pResult->nImage = iIconCRL;
				}
			}
			break;

		case CERTMGR_AUTO_CERT_REQUEST:
			{
				CAutoCertRequest* pACR = reinterpret_cast <CAutoCertRequest*> (pCookie);
				ASSERT (pACR);
				if ( pACR )
				{
					if (pResult->mask & RDI_STR)
					{
						// Note:  text is first stored in class variable so that the buffer is
						// somewhat persistent.  Copying the buffer pointer directly to the
						// pResult->str would result in the buffer being freed before the pointer
						// is used.
						switch (pResult->nCol)
						{
						case 0:
							{
								CString	name;

								if ( SUCCEEDED (pACR->GetCertTypeName (name)) )
									m_szDisplayInfoResult = name;
								else
									SetTextNotAvailable ();
							}
							break;

						default:
							ASSERT (0);
							break;
						}

						pResult->str = const_cast<LPWSTR> ( (LPCWSTR) m_szDisplayInfoResult);
					}
					if (pResult->mask & RDI_IMAGE)
						pResult->nImage = iIconAutoCertRequest;
				}
			}
			break;
		}
     }
	else
		hr = CComponent::GetDisplayInfo (pResult);

	return hr;
}


///////////////////////////////////////////////////////////////////////////////
// IExtendContextMenu implementation
//
STDMETHODIMP CCertMgrComponent::AddMenuItems (LPDATAOBJECT pDataObject,
                                                          LPCONTEXTMENUCALLBACK pContextMenuCallback,
                                                          long *pInsertionAllowed)
{
	_TRACE (1, L"Entering CCertMgrComponent::AddMenuItems\n");
	HRESULT	hr = S_OK;
	hr = QueryComponentDataRef ().AddMenuItems (pDataObject,
			pContextMenuCallback, pInsertionAllowed);
	_TRACE (-1, L"Leaving CCertMgrComponent::AddMenuItems: 0x%x\n", hr);
	return hr;
}


STDMETHODIMP CCertMgrComponent::Command (long nCommandID, LPDATAOBJECT pDataObject)
{
	_TRACE (1, L"Entering CCertMgrComponent::Command\n");
	HRESULT	hr = S_OK;

	switch (nCommandID)
	{
	case IDM_OPEN:
	case IDM_TASK_OPEN:
		hr = OnOpen (pDataObject);
		break;

	default:
		hr = QueryComponentDataRef ().Command (nCommandID, pDataObject);
		break;
	}
	_TRACE (-1, L"Leaving CCertMgrComponent::Command: 0x%x\n", hr);
	return hr;
}


HRESULT CCertMgrComponent::OnNotifyDblClick (LPDATAOBJECT pDataObject)
{
	_TRACE (1, L"Entering CCertMgrComponent::OnNotifyDblClick\n");
	HRESULT	hr = S_OK;
	ASSERT (pDataObject);

	CCertMgrCookie* pParentCookie =
			QueryComponentDataRef ().ConvertCookie (pDataObject);
	if ( pParentCookie )
	{
		switch ( pParentCookie->m_objecttype )
		{
			case CERTMGR_SNAPIN:
			case CERTMGR_USAGE:
			case CERTMGR_PHYS_STORE:
			case CERTMGR_LOG_STORE:
			case CERTMGR_LOG_STORE_GPE:
   			case CERTMGR_LOG_STORE_RSOP:
			case CERTMGR_CRL_CONTAINER:
			case CERTMGR_CTL_CONTAINER:
			case CERTMGR_CERT_CONTAINER:
			case CERTMGR_AUTO_CERT_REQUEST:
			case CERTMGR_CERT_POLICIES_USER:
			case CERTMGR_CERT_POLICIES_COMPUTER:
            case CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS:
            case CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS:
            case CERTMGR_SAFER_COMPUTER_TRUSTED_PUBLISHERS:
            case CERTMGR_SAFER_USER_TRUSTED_PUBLISHERS:
            case CERTMGR_SAFER_COMPUTER_DEFINED_FILE_TYPES:
            case CERTMGR_SAFER_USER_DEFINED_FILE_TYPES:
            case CERTMGR_SAFER_COMPUTER_LEVEL:
            case CERTMGR_SAFER_USER_LEVEL:
            case CERTMGR_SAFER_COMPUTER_ENTRY:
            case CERTMGR_SAFER_USER_ENTRY:
            case CERTMGR_SAFER_USER_ROOT:
            case CERTMGR_SAFER_USER_ENTRIES:
            case CERTMGR_SAFER_COMPUTER_ENTRIES:
            case CERTMGR_SAFER_USER_LEVELS:
            case CERTMGR_SAFER_COMPUTER_LEVELS:
            case CERTMGR_SAFER_COMPUTER_ROOT:
            case CERTMGR_SAFER_COMPUTER_ENFORCEMENT:
            case CERTMGR_SAFER_USER_ENFORCEMENT:
    			hr = S_FALSE;
				break;

			case CERTMGR_CERTIFICATE:
				{
					CCertificate*	pCert = reinterpret_cast <CCertificate*> (pParentCookie);
					ASSERT (pCert);
					if ( pCert )
						hr = LaunchCommonCertDialog (pCert);
					else
						hr = E_UNEXPECTED;
				}
				hr = S_OK;
				break;


			case CERTMGR_CTL:
				{
					CCTL*	pCTL = reinterpret_cast <CCTL*> (pParentCookie);
					ASSERT (pCTL);
					if ( pCTL )
						hr = LaunchCommonCTLDialog (pCTL);
					else
						hr = E_UNEXPECTED;
				}
				hr = S_OK;
				break;

			case CERTMGR_CRL:
				{
					CCRL*	pCRL = reinterpret_cast <CCRL*> (pParentCookie);
					ASSERT (pCRL);
					if ( pCRL )
						hr = LaunchCommonCRLDialog (pCRL);
					else
						hr = E_UNEXPECTED;
				}
				hr = S_OK;
				break;

			default:
				_TRACE (0, L"CCertMgrComponentData::EnumerateScopeChildren bad parent type\n");
				ASSERT (FALSE);
				hr = S_OK;
				break;
		}
	}
	else
		hr =  E_UNEXPECTED;


	_TRACE (-1, L"Leaving CCertMgrComponent::OnNotifyDblClick: 0x%x\n", hr);
	return hr;
}


HRESULT CCertMgrComponent::OnNotifySelect (LPDATAOBJECT pDataObject, BOOL fSelected)
{
	_TRACE (0, L"Entering CCertMgrComponent::OnNotifySelect - fSelected == %d.\n", fSelected);
     ASSERT (m_pConsoleVerb && 0xdddddddd != (UINT_PTR) m_pConsoleVerb);
	if ( !m_pConsoleVerb || 0xdddddddd == (UINT_PTR) m_pConsoleVerb )
		return E_FAIL;


	HRESULT	hr = S_OK;
	CCertMgrComponentData& compData = QueryComponentDataRef ();
	BOOL	bIsFileView = !(compData.m_szFileName.IsEmpty ());

	// Don't add menu items if this is a serialized file
    CertificateManagerObjectType objectType = compData.GetObjectType (pDataObject);
	switch (objectType)
	{
	case CERTMGR_SNAPIN:
		if ( fSelected )
		{
            m_pConsoleVerb->SetDefaultVerb (MMC_VERB_OPEN);
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, TRUE);
		}
		else
		{
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, FALSE);
		}
		m_currResultNodeType = CERTMGR_INVALID;
		break;

	case CERTMGR_USAGE:
		m_currResultNodeType = CERTMGR_CERTIFICATE;
		{
			CCertMgrCookie* pCookie = ConvertCookie (pDataObject);
			if ( pCookie )
			{
				CUsageCookie* pUsage = reinterpret_cast <CUsageCookie*> (pCookie);
				ASSERT (pUsage);
				if ( pUsage )
				{
                    if ( m_pLastUsageCookie )
                        m_pLastUsageCookie->Release ();
                    m_pLastUsageCookie = pUsage;
                    m_pLastUsageCookie->AddRef ();
					hr = DisplayCertificateCountByUsage (pCookie->GetObjectName (),
							pUsage->GetCertCount ());
				}
				else
					hr = E_UNEXPECTED;
			}
			else
				hr = E_UNEXPECTED;
		}
		if ( fSelected )
		{
            m_pConsoleVerb->SetDefaultVerb (MMC_VERB_OPEN);
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, TRUE);
		}
		else
		{
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, FALSE);
		}
		break;

	case CERTMGR_PHYS_STORE:
	case CERTMGR_LOG_STORE:
		if ( fSelected )
        {
            m_pConsoleVerb->SetDefaultVerb (MMC_VERB_OPEN);
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, TRUE);
        }
		else
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, FALSE);
		if ( !bIsFileView )
		{
			CCertMgrCookie* pCookie = ConvertCookie (pDataObject);
			if ( pCookie )
			{
				CCertStore* pStore = reinterpret_cast <CCertStore*> (pCookie);
				ASSERT (pStore);
				if ( pStore )
				{
					pStore->GetStoreHandle (); // to initialize read-only flag
					if ( pStore->IsReadOnly () ) //|| !fSelected)
						m_pConsoleVerb->SetVerbState (MMC_VERB_PASTE, ENABLED, FALSE);
					else
						m_pConsoleVerb->SetVerbState (MMC_VERB_PASTE, ENABLED, TRUE);
                    if ( fSelected )
					    hr = DisplayCertificateCountByStore (m_pConsole, pStore);
					pStore->Close ();
				}
				else
					hr = E_UNEXPECTED;
			}
			else
				hr = E_UNEXPECTED;
		}
		m_currResultNodeType = CERTMGR_INVALID;
		break;
	
	case CERTMGR_LOG_STORE_GPE:
	case CERTMGR_LOG_STORE_RSOP:
		if ( fSelected && CERTMGR_LOG_STORE_RSOP != QueryComponentDataRef ().GetObjectType (pDataObject) )
        {
            m_pConsoleVerb->SetDefaultVerb (MMC_VERB_OPEN);
            m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, TRUE);
        }
		else
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, FALSE);
		if ( !bIsFileView )
		{
			CCertMgrCookie* pCookie = ConvertCookie (pDataObject);
			if ( pCookie )
			{
				CCertStoreGPE* pStore = reinterpret_cast <CCertStoreGPE*> (pCookie);
				ASSERT (pStore);
				if ( pStore )
				{
					hr = DisplayCertificateCountByStore (m_pConsole, pStore, true);

					switch (pStore->GetStoreType ())
					{
					case ROOT_STORE:
						if ( fSelected )
							m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, TRUE);
						else
							m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, FALSE);
						m_currResultNodeType = CERTMGR_CERTIFICATE;
						break;

					case EFS_STORE:
    				    if ( fSelected )
						    m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, TRUE);
					    else
						    m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, FALSE);
    					m_currResultNodeType = CERTMGR_CERTIFICATE;
						break;

					case TRUST_STORE:
                        if ( compData.m_bIsRSOP )
                        {
						    if ( fSelected )
							    m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, TRUE);
						    else
							    m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, FALSE);
                        }
						m_currResultNodeType = CERTMGR_CTL;
						break;

					case ACRS_STORE:
                        if ( compData.m_bIsRSOP )
                        {
						    if ( fSelected )
							    m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, TRUE);
						    else
							    m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, FALSE);
                        }
						m_currResultNodeType = CERTMGR_AUTO_CERT_REQUEST;
						break;

					default:
						ASSERT (0);
						m_currResultNodeType = CERTMGR_INVALID;
						break;
					}
					
					if ( pStore->IsReadOnly () ) //|| !fSelected )
						m_pConsoleVerb->SetVerbState (MMC_VERB_PASTE, ENABLED, FALSE);
					else if ( ACRS_STORE != pStore->GetStoreType () )
					{
						// Do not allow cut and paste for ACRS store.
						m_pConsoleVerb->SetVerbState (MMC_VERB_PASTE, ENABLED, TRUE);
						if ( !fSelected &&
								CERTMGR_LOG_STORE_GPE != pStore->m_objecttype )
						{
							pStore->Commit ();
						}
					}
				}
				else
					hr = E_UNEXPECTED;
			}
			else
				hr = E_UNEXPECTED;
		}
		break;
	
	case CERTMGR_CERTIFICATE:
		{
			CCertMgrCookie* pCookie = ConvertCookie (pDataObject);
			ASSERT (pCookie);
			if ( pCookie )
			{
				CCertificate* pCert = reinterpret_cast <CCertificate*> (pCookie);
				ASSERT (pCert);
				if ( pCert )
				{
                    if ( fSelected )
                    {
					    if ( IDM_STORE_VIEW == QueryComponentDataRef ().m_activeViewPersist )
					    {
						    hr = DisplayCertificateCountByStore (
								    m_pConsole, pCert->GetCertStore ());
					    }
					    else
					    {
						    // Display by count in each purpose
                            ASSERT (m_pLastUsageCookie);
                            if ( m_pLastUsageCookie )
                            {
    					         hr = DisplayCertificateCountByUsage (
                                        m_pLastUsageCookie->GetObjectName (),
	    						        m_pLastUsageCookie->GetCertCount ());
                            }
					    }
                    }

					if ( fSelected )
						m_pConsoleVerb->SetVerbState (MMC_VERB_COPY, ENABLED, TRUE);
					else
						m_pConsoleVerb->SetVerbState (MMC_VERB_COPY, ENABLED, FALSE);
					if ( !bIsFileView )
					{
						if ( fSelected )
							m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, TRUE);
						else
							m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, FALSE);

                        CCertStore* pCertStore = pCert->GetCertStore ();
                        if ( pCertStore )
                        {
						    if ( pCertStore->IsReadOnly () || !fSelected )
							    m_pConsoleVerb->SetVerbState (MMC_VERB_DELETE, ENABLED, FALSE);
						    else
						    {
							    if ( pCert->CanDelete () )
								    m_pConsoleVerb->SetVerbState (MMC_VERB_DELETE, ENABLED, TRUE);
							    else
								    m_pConsoleVerb->SetVerbState (MMC_VERB_DELETE, ENABLED, FALSE);

							    if ( !fSelected &&
									    CERTMGR_LOG_STORE_GPE == pCertStore->m_objecttype )
							    {
								    pCertStore->Commit ();
							    }
						    }
                        }
					}
				}
				else
					hr = E_UNEXPECTED;
			}
			else
				hr = E_UNEXPECTED;
		}
		m_currResultNodeType = CERTMGR_CERTIFICATE;
		break;

	case CERTMGR_CRL_CONTAINER:
		if ( fSelected )
        {
            m_pConsoleVerb->SetDefaultVerb (MMC_VERB_OPEN);
            m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, TRUE);
        }
		else
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, FALSE);
		if ( !bIsFileView )
		{
			CCertMgrCookie* pCookie = ConvertCookie (pDataObject);
			if ( pCookie )
			{
				CContainerCookie* pCont = reinterpret_cast <CContainerCookie*> (pCookie);
				ASSERT (pCont);
				if ( pCont )
				{
				    if ( pCont->GetCertStore ().IsReadOnly () ) //|| !fSelected )
					    m_pConsoleVerb->SetVerbState (MMC_VERB_PASTE, ENABLED, FALSE);
				    else
				    {
					    m_pConsoleVerb->SetVerbState (MMC_VERB_PASTE, ENABLED, TRUE);
					    if ( !fSelected )
						    pCont->GetCertStore ().Commit ();
                    }
				}
				else
					hr = E_UNEXPECTED;
			}
			else
				hr = E_UNEXPECTED;
		}
		m_currResultNodeType = CERTMGR_CRL;
		break;

	case CERTMGR_CTL_CONTAINER:
		if ( fSelected )
        {
            m_pConsoleVerb->SetDefaultVerb (MMC_VERB_OPEN);
            m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, TRUE);
        }
		else
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, FALSE);
		if ( !bIsFileView )
		{
			CCertMgrCookie* pCookie = ConvertCookie (pDataObject);
			if ( pCookie )
			{
				CContainerCookie* pCont = reinterpret_cast <CContainerCookie*> (pCookie);
				ASSERT (pCont);
				if ( pCont )
				{
					if ( pCont->GetCertStore ().IsReadOnly () ) //|| !fSelected )
						m_pConsoleVerb->SetVerbState (MMC_VERB_PASTE, ENABLED, FALSE);
					else
					{
						m_pConsoleVerb->SetVerbState (MMC_VERB_PASTE, ENABLED, TRUE);
						if ( !fSelected )
							pCont->GetCertStore ().Commit ();
					}
				}
				else
					hr = E_UNEXPECTED;
			}
			else
				hr = E_UNEXPECTED;
		}
		m_currResultNodeType = CERTMGR_CTL;
		break;

	case CERTMGR_CERT_CONTAINER:
		if ( fSelected )
        {
            m_pConsoleVerb->SetDefaultVerb (MMC_VERB_OPEN);
            m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, TRUE);
        }
		else
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, FALSE);
		if ( !bIsFileView )
		{
			CCertMgrCookie* pCookie = ConvertCookie (pDataObject);
			if ( pCookie )
			{
				CContainerCookie* pCont = reinterpret_cast <CContainerCookie*> (pCookie);
				ASSERT (pCont);
				if ( pCont )
				{
                    if ( fSelected )
					    hr = DisplayCertificateCountByStore (
						    	m_pConsole, &pCont->GetCertStore ());
					if ( pCont->GetCertStore ().IsReadOnly () ) //|| !fSelected )
						m_pConsoleVerb->SetVerbState (MMC_VERB_PASTE, ENABLED, FALSE);
					else
					{
						m_pConsoleVerb->SetVerbState (MMC_VERB_PASTE, ENABLED, TRUE);
						if ( !fSelected )
							pCont->GetCertStore ().Commit ();
					}
				}
				else
					hr = E_UNEXPECTED;
			}
			else
				hr = E_UNEXPECTED;
		}
		m_currResultNodeType = CERTMGR_CERTIFICATE;
		break;

	case CERTMGR_CRL:
		if ( fSelected )
			m_pConsoleVerb->SetVerbState (MMC_VERB_COPY, ENABLED, TRUE);
		else
			m_pConsoleVerb->SetVerbState (MMC_VERB_COPY, ENABLED, FALSE);
		{
			CCertMgrCookie* pCookie = ConvertCookie (pDataObject);
			if ( pCookie )
			{
				CCRL* pCRL = reinterpret_cast <CCRL*> (pCookie);
				ASSERT (pCRL);
				if ( pCRL )
				{
					if ( pCRL->GetCertStore ().IsReadOnly () || !fSelected )
						m_pConsoleVerb->SetVerbState (MMC_VERB_DELETE, ENABLED, FALSE);
					else
					{
						m_pConsoleVerb->SetVerbState (MMC_VERB_DELETE, ENABLED, TRUE);
						if ( !fSelected &&
								CERTMGR_LOG_STORE_GPE == pCRL->GetCertStore ().m_objecttype )
						{
							pCRL->GetCertStore ().Commit ();
						}
					}
				}
				else
					hr = E_UNEXPECTED;
			}
			else
				hr = E_UNEXPECTED;
		}
		m_currResultNodeType = CERTMGR_CRL;
		break;

	case CERTMGR_AUTO_CERT_REQUEST:
		if ( fSelected )
		{
			m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, TRUE);
			m_pConsoleVerb->SetDefaultVerb (MMC_VERB_PROPERTIES);
			m_pConsoleVerb->SetVerbState (MMC_VERB_COPY, ENABLED, TRUE);
		}
		else
		{
			m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, FALSE);
			m_pConsoleVerb->SetVerbState (MMC_VERB_COPY, ENABLED, FALSE);
		}

		{
			CCertMgrCookie* pCookie = ConvertCookie (pDataObject);
			if ( pCookie )
			{
				CAutoCertRequest* pAutoCert = reinterpret_cast <CAutoCertRequest*> (pCookie);
				ASSERT (pAutoCert);
				if ( pAutoCert )
				{
					if ( pAutoCert->GetCertStore ().IsReadOnly () || !fSelected )
						m_pConsoleVerb->SetVerbState (MMC_VERB_DELETE, ENABLED, FALSE);
					else
					{
						m_pConsoleVerb->SetVerbState (MMC_VERB_DELETE, ENABLED, TRUE);
						if ( !fSelected &&
								CERTMGR_LOG_STORE_GPE == pAutoCert->GetCertStore ().m_objecttype )
						{
							pAutoCert->GetCertStore ().Commit ();
						}
					}
				}
				else
					hr = E_UNEXPECTED;
			}
			else
				hr = E_UNEXPECTED;
		}
		m_currResultNodeType = CERTMGR_AUTO_CERT_REQUEST;
		break;

	case CERTMGR_CTL:
		if ( !bIsFileView )
		{
			CCertMgrCookie* pCookie = ConvertCookie (pDataObject);
			if ( pCookie )
			{
				CCTL* pCTL = reinterpret_cast <CCTL*> (pCookie);
				ASSERT (pCTL);
				if ( pCTL )
				{
					if ( pCTL->GetCertStore ().IsReadOnly () || !fSelected )
						m_pConsoleVerb->SetVerbState (MMC_VERB_DELETE, ENABLED, FALSE);
					else
					{
						m_pConsoleVerb->SetVerbState (MMC_VERB_DELETE, ENABLED, TRUE);
						if ( !fSelected &&
								CERTMGR_LOG_STORE_GPE == pCTL->GetCertStore ().m_objecttype )
						{
							pCTL->GetCertStore ().Commit ();
						}
					}

					// Don't allow auto cert requests to be copied. They can't be
					// pasted anywhere.
					if ( ACRS_STORE != pCTL->GetCertStore ().GetStoreType () )
						m_pConsoleVerb->SetVerbState (MMC_VERB_COPY, ENABLED, TRUE);
				}
				else
					hr = E_UNEXPECTED;
			}
			else
				hr = E_UNEXPECTED;
		}
		m_currResultNodeType = CERTMGR_CTL;
		break;

	case CERTMGR_CERT_POLICIES_COMPUTER:
	case CERTMGR_CERT_POLICIES_USER:
		m_currResultNodeType = CERTMGR_INVALID;
		if ( fSelected )
		{
            m_pConsoleVerb->SetDefaultVerb (MMC_VERB_OPEN);
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, TRUE);
		}
		else
		{
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, FALSE);
		}
		break;

	case CERTMGR_MULTISEL:
		{
			if ( fSelected )
				m_pConsoleVerb->SetVerbState (MMC_VERB_COPY, ENABLED, TRUE);
			else
				m_pConsoleVerb->SetVerbState (MMC_VERB_COPY, ENABLED, FALSE);

			bool	bDeleteSet = false;


			CCertMgrDataObject* pDO = reinterpret_cast <CCertMgrDataObject*>(pDataObject);
			ASSERT (pDO);
			if ( pDO )
			{
				// Is multiple select, get all selected items and delete - confirm
				// first deletion only.
				CCertMgrCookie*	pCookie = 0;
				pDO->Reset();
				while (pDO->Next(1, reinterpret_cast<MMC_COOKIE*>(&pCookie), NULL) != S_FALSE)
				{
					if ( CERTMGR_CERTIFICATE == pCookie->m_objecttype )
					{
						CCertificate* pCert = reinterpret_cast <CCertificate*> (pCookie);
						ASSERT (pCert);
						if ( (pCert && !pCert->CanDelete ()) || !fSelected )
						{
							m_pConsoleVerb->SetVerbState (MMC_VERB_DELETE, ENABLED, FALSE);
							bDeleteSet = true;
							break;
						}
					}
					else
						break;
				}
			}

			if ( !bDeleteSet && fSelected )
				m_pConsoleVerb->SetVerbState (MMC_VERB_DELETE, ENABLED, TRUE);
		}
		m_currResultNodeType = CERTMGR_MULTISEL;
		break;

    case CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS:
    case CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS:
    case CERTMGR_SAFER_COMPUTER_LEVEL:
    case CERTMGR_SAFER_USER_LEVEL:
    case CERTMGR_SAFER_COMPUTER_TRUSTED_PUBLISHERS:
    case CERTMGR_SAFER_USER_TRUSTED_PUBLISHERS:
    case CERTMGR_SAFER_COMPUTER_DEFINED_FILE_TYPES:
    case CERTMGR_SAFER_USER_DEFINED_FILE_TYPES:
    case CERTMGR_SAFER_COMPUTER_ENFORCEMENT:
    case CERTMGR_SAFER_USER_ENFORCEMENT:
		if ( fSelected )
		{
			m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, TRUE);
			m_pConsoleVerb->SetDefaultVerb (MMC_VERB_PROPERTIES);
		}
		else
		{
			m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, FALSE);
		}
        break;

    case CERTMGR_SAFER_COMPUTER_ENTRY:
    case CERTMGR_SAFER_USER_ENTRY:
		if ( fSelected )
		{
			m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, TRUE);
			m_pConsoleVerb->SetDefaultVerb (MMC_VERB_PROPERTIES);
            m_pConsoleVerb->SetVerbState (MMC_VERB_DELETE, ENABLED, TRUE);
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, TRUE);
		}
		else
		{
			m_pConsoleVerb->SetVerbState (MMC_VERB_PROPERTIES, ENABLED, FALSE);
            m_pConsoleVerb->SetVerbState (MMC_VERB_DELETE, ENABLED, FALSE);
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, FALSE);
		}
        break;

    case CERTMGR_SAFER_COMPUTER_ENTRIES:
    case CERTMGR_SAFER_USER_ENTRIES:
		if ( fSelected )
		{
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, TRUE);
            m_pConsoleVerb->SetVerbState (MMC_VERB_PASTE, ENABLED, TRUE);
            m_pConsoleVerb->SetDefaultVerb (MMC_VERB_OPEN);
		}
		else
		{
			m_pConsoleVerb->SetVerbState (MMC_VERB_REFRESH, ENABLED, FALSE);
            m_pConsoleVerb->SetVerbState (MMC_VERB_PASTE, ENABLED, FALSE);
		}
        break;

    case CERTMGR_SAFER_COMPUTER_LEVELS:
    case CERTMGR_SAFER_USER_LEVELS:
        if ( fSelected )
            m_pConsoleVerb->SetDefaultVerb (MMC_VERB_OPEN);
        break;

    case CERTMGR_SAFER_COMPUTER_ROOT:
    case CERTMGR_SAFER_USER_ROOT:
        if ( fSelected )
            m_pConsoleVerb->SetDefaultVerb (MMC_VERB_OPEN);
        {
            CString szStatusText;

            if ( !QueryComponentDataRef ().m_bSaferSupported )
		    {
                szStatusText.LoadString (IDS_SAFER_NOT_SUPPORTED);
            }
            IConsole2*	pConsole2 = 0;
            hr = m_pConsole->QueryInterface (
                    IID_PPV_ARG(IConsole2, &pConsole2));
            if (SUCCEEDED (hr))
            {
                hr = pConsole2->SetStatusText (const_cast <LPOLESTR>((PCWSTR) szStatusText));
                if ( !SUCCEEDED (hr) )
                {
                    _TRACE (0, L"IConsole::SetStatusText () failed: %x", hr);
                }
            pConsole2->Release ();
            }
        }
        break;

    default:
		m_currResultNodeType = CERTMGR_INVALID;
		hr = E_UNEXPECTED;
		break;
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::OnNotifySelect: 0x%x\n", hr);
	return hr;
}

STDMETHODIMP CCertMgrComponent::CreatePropertyPages (
	LPPROPERTYSHEETCALLBACK pCallBack,
     LONG_PTR handle,		// This handle must be saved in the property page object to notify the parent when modified
	LPDATAOBJECT pDataObject)
{
	_TRACE (1, L"Entering CCertMgrComponent::CreatePropertyPages\n");
	HRESULT	hr = S_OK;

	hr = QueryComponentDataRef ().CreatePropertyPages (pCallBack, handle, pDataObject);
	_TRACE (-1, L"Leaving CCertMgrComponent::CreatePropertyPages: 0x%x\n", hr);
	return hr;
}

STDMETHODIMP CCertMgrComponent::QueryPagesFor (LPDATAOBJECT pDataObject)
{
	_TRACE (1, L"Entering CCertMgrComponent::QueryPagesFor\n");
	HRESULT	hr = S_OK;
	hr = QueryComponentDataRef ().QueryPagesFor (pDataObject);
	_TRACE (-1, L"Leaving CCertMgrComponent::QueryPagesFor: 0x%x\n", hr);
	return hr;
}


HRESULT CCertMgrComponent::OnNotifyRefresh (LPDATAOBJECT pDataObject)
{
	_TRACE (1, L"Entering CCertMgrComponent::OnNotifyRefresh\n");
	ASSERT (pDataObject);
	if ( !pDataObject )
		return E_POINTER;

	HRESULT	hr = S_OK;

	CCertMgrCookie* pCookie = ConvertCookie (pDataObject);
	if ( !pCookie )
		return E_UNEXPECTED;

	CCertMgrComponentData&	dataRef = QueryComponentDataRef ();
	
	switch (pCookie->m_objecttype)
	{
	case CERTMGR_CERT_POLICIES_USER:
	case CERTMGR_CERT_POLICIES_COMPUTER:
		if ( dataRef.m_bIsRSOP )
		{
			// Delete all the scope items and force a reexpansion
			
			hr = dataRef.DeleteScopeItems (pCookie->m_hScopeItem);

            hr = dataRef.BuildWMIList (0, 
                    CERTMGR_CERT_POLICIES_COMPUTER == pCookie->m_objecttype);
            if ( SUCCEEDED (hr) )
            {
    			GUID	guid;
	    		hr = dataRef.ExpandScopeNodes (
		    			pCookie, pCookie->m_hScopeItem,
			    		_T (""), 0, guid);
            }
		}
		break;

	case CERTMGR_SNAPIN:
		{
			// Close and release the usage stores if any.
			CloseAndReleaseUsageStores ();
			m_bUsageStoresEnumerated = false;

			// Delete all the scope items and force a reexpansion
			hr = dataRef.DeleteScopeItems ();

            if ( dataRef.m_bIsRSOP )
            {
                ASSERT (0);  // do we ever hit this?
                hr = dataRef.BuildWMIList (0, true);
            }

            if ( SUCCEEDED (hr) )
            {
    			GUID	guid;
	    		hr = dataRef.ExpandScopeNodes (
		    			dataRef.m_pRootCookie, dataRef.m_hRootScopeItem,
			    		_T (""), 0, guid);
            }
		}
		break;

	case CERTMGR_PHYS_STORE:
	case CERTMGR_LOG_STORE:
		{
			CCertStore*	pCertStore = reinterpret_cast <CCertStore*> (pCookie);
			ASSERT (pCertStore);
			if ( pCertStore )
				pCertStore->Resync ();

			HSCOPEITEM	hScopeItem = pCookie->m_hScopeItem;
			ASSERT (hScopeItem);
			if ( hScopeItem )
			{
				hr = dataRef.DeleteChildren (hScopeItem);
				GUID	guid;
				hr = dataRef.ExpandScopeNodes (
						pCookie, hScopeItem, _T (""), 0, guid);
				if ( SUCCEEDED (hr) )
				{
					hr = RefreshResultPane ();
					ASSERT (SUCCEEDED (hr));
				}
			}
		}
		break;

	case CERTMGR_CRL_CONTAINER:
	case CERTMGR_CTL_CONTAINER:
	case CERTMGR_CERT_CONTAINER:
		{
			CContainerCookie* pContainer = reinterpret_cast <CContainerCookie*> (pCookie);
			ASSERT (pContainer);
			if ( pContainer )
			{
				pContainer->GetCertStore ().Resync ();
			}
		}
		hr = RefreshResultPane ();
		ASSERT (SUCCEEDED (hr));
		break;


	case CERTMGR_LOG_STORE_GPE:
		{
			CCertStore*	pCertStore = reinterpret_cast <CCertStore*> (pCookie);
			ASSERT (pCertStore);
			if ( pCertStore )
				pCertStore->Resync ();
		}
		hr = RefreshResultPane ();
		ASSERT (SUCCEEDED (hr));
		break;

	case CERTMGR_LOG_STORE_RSOP:
        // must be refreshed at root node
        ASSERT (0);
        break;

	case CERTMGR_USAGE:
		// Close all the stores.  This will force them to be
		// re-enumerated later.
		CloseAndReleaseUsageStores ();
		m_bUsageStoresEnumerated = false;
		hr = RefreshResultPane ();
		ASSERT (SUCCEEDED (hr));
		break;


	case CERTMGR_AUTO_CERT_REQUEST:
		hr = RefreshResultPane ();
		ASSERT (SUCCEEDED (hr));
		break;

	case CERTMGR_CERTIFICATE:
		{
			CCertificate* pCert = reinterpret_cast <CCertificate*> (pCookie);
			ASSERT (pCert);
			if ( pCert )
			{
                CCertStore* pStore = pCert->GetCertStore ();
                if ( pStore )
				    pStore->Resync ();
			}
		}
		hr = RefreshResultItem (pCookie);
		ASSERT (SUCCEEDED (hr));
		break;

	case CERTMGR_CTL:
		{
			CCTL* pCTL = reinterpret_cast <CCTL*> (pCookie);
			ASSERT (pCTL);
			if ( pCTL )
			{
				pCTL->GetCertStore ().Resync ();
			}
		}
		hr = RefreshResultItem (pCookie);
		ASSERT (SUCCEEDED (hr));
		break;

	case CERTMGR_CRL:
		{
			CCRL* pCRL = reinterpret_cast <CCRL*> (pCookie);
			ASSERT (pCRL);
			if ( pCRL )
			{
				pCRL->GetCertStore ().Resync ();
			}
		}
		hr = RefreshResultItem (pCookie);
		ASSERT (SUCCEEDED (hr));
		break;

    case CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS:
    case CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS:
        ASSERT (0);
        break;

    case CERTMGR_SAFER_COMPUTER_ENTRIES:
    case CERTMGR_SAFER_USER_ENTRIES:
        {
            bool    bAllowRefresh = true;

            RESULTDATAITEM  rdItem;
            ::ZeroMemory (&rdItem, sizeof (RESULTDATAITEM));
            rdItem.nIndex = -1;
            rdItem.mask = RDI_STATE | RDI_PARAM | RDI_INDEX;
            do
            {
                hr = m_pResultData->GetNextItem (&rdItem);
                if ( SUCCEEDED (hr) )
                {
                    CCertMgrCookie* pCurrCookie = (CCertMgrCookie*) rdItem.lParam;
                    if ( pCurrCookie )
                    {
                        if ( pCurrCookie->HasOpenPropertyPages () )
                        {
		                    CString text;
		                    CString	caption;

		                    VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
		                    VERIFY (text.LoadString (IDS_CANT_REFRESH_PAGES_OPEN));
		                    int		iRetVal = 0;
		                    VERIFY (SUCCEEDED (m_pConsole->MessageBox (text, caption,
				                    MB_OK, &iRetVal)));
                            bAllowRefresh = false;
                            break;
                        }
                    }
                }
            } while ( SUCCEEDED (hr) && -1 != rdItem.nIndex );


            if ( !bAllowRefresh )
                break;
        }

		hr = RefreshResultPane ();
		ASSERT (SUCCEEDED (hr));
        break;

    case CERTMGR_SAFER_COMPUTER_ENTRY:
    case CERTMGR_SAFER_USER_ENTRY:
		hr = RefreshResultPane ();
		ASSERT (SUCCEEDED (hr));
        break;

	default:
		ASSERT (0);
		hr = E_UNEXPECTED;
		break;
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::OnNotifyRefresh: 0x%x\n", hr);
	return hr;
}

void CCertMgrComponent::SetTextNotAvailable ()
{
	_TRACE (1, L"Entering CCertMgrComponent::SetTextNotAvailable\n");
	AFX_MANAGE_STATE (AfxGetStaticModuleState ());
	m_szDisplayInfoResult.LoadString (IDS_NOT_AVAILABLE);
	_TRACE (-1, L"Leaving CCertMgrComponent::SetTextNotAvailable\n");
}


HRESULT	CCertMgrComponent::DeleteCookie (
        CCertMgrCookie* pCookie, 
        LPDATAOBJECT pDataObject, 
        bool bRequestConfirmation, 
        bool bIsMultipleSelect, 
        bool bDoCommit)
{
	_TRACE (1, L"Entering CCertMgrComponent::DeleteCookie\n");
    AFX_MANAGE_STATE (AfxGetStaticModuleState ());
	HRESULT	hr = S_OK;
	CString	text;
	CString	caption;
	int		iRetVal = IDYES;

	switch (pCookie->m_objecttype)
	{
	case CERTMGR_CERTIFICATE:
		{
			CCertificate* pCert = reinterpret_cast <CCertificate*> (pCookie);
			ASSERT (pCert);
			if ( pCert )
			{
				if ( bRequestConfirmation )
				{
					switch ( pCert->GetStoreType () )
					{
					case ROOT_STORE:
						if ( bIsMultipleSelect )
						{
							if ( IDM_USAGE_VIEW == QueryComponentDataRef ().m_activeViewPersist )
								VERIFY (text.LoadString (IDS_CONFIRM_DELETE_MULT_CERT_BY_PURPOSE));
							else
								VERIFY (text.LoadString (IDS_CONFIRM_DELETE_ROOT_MULTI_CERT));
						}
						else
							VERIFY (text.LoadString (IDS_CONFIRM_DELETE_ROOT_CERT));
						break;

					case CA_STORE:
						if ( bIsMultipleSelect )
						{
							if ( IDM_USAGE_VIEW == QueryComponentDataRef ().m_activeViewPersist )
								VERIFY (text.LoadString (IDS_CONFIRM_DELETE_MULT_CERT_BY_PURPOSE));
							else
								VERIFY (text.LoadString (IDS_CONFIRM_DELETE_CA_MULTI_CERT));
						}
						else
							VERIFY (text.LoadString (IDS_CONFIRM_DELETE_CA_CERT));
						break;

					case MY_STORE:
						if ( bIsMultipleSelect )
						{
							if ( IDM_USAGE_VIEW == QueryComponentDataRef ().m_activeViewPersist )
								VERIFY (text.LoadString (IDS_CONFIRM_DELETE_MULT_CERT_BY_PURPOSE));
							else
								VERIFY (text.LoadString (IDS_CONFIRM_DELETE_MY_MULTI_CERT));
						}
						else
							VERIFY (text.LoadString (IDS_CONFIRM_DELETE_MY_CERT));
						break;

					default:
						if ( bIsMultipleSelect )
						{
							if ( IDM_USAGE_VIEW == QueryComponentDataRef ().m_activeViewPersist )
								VERIFY (text.LoadString (IDS_CONFIRM_DELETE_MULT_CERT_BY_PURPOSE));
							else
								VERIFY (text.LoadString (IDS_CONFIRM_DELETE_MULTI));
						}
						else
							VERIFY (text.LoadString (IDS_CONFIRM_DELETE));
						break;
					}
					VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
					hr = m_pConsole->MessageBox (text, caption, MB_ICONWARNING | MB_YESNO, &iRetVal);
					ASSERT (SUCCEEDED (hr));
				}

				if ( IDYES == iRetVal )
				{
                    CWaitCursor waitCursor;
					pCert->GetCertStore (); // to initialize handle

					hr = DeleteCertFromResultPane (pCert, pDataObject, bDoCommit);
				}
				else
					hr = E_FAIL;
			}
		}
		break;

	case CERTMGR_CRL:
		{
			CCRL* pCRL = reinterpret_cast <CCRL*> (pCookie);
			ASSERT (pCRL);
			if ( pCRL )
			{
				if ( m_pPastedDO != pDataObject )
				{
					VERIFY (text.LoadString (IDS_CONFIRM_DELETE_CRL));
					VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
					hr = m_pConsole->MessageBox (text, caption, MB_ICONWARNING | MB_YESNO, &iRetVal);
					ASSERT (SUCCEEDED (hr));
				}

				if ( IDYES == iRetVal )
				{
                          CWaitCursor waitCursor;
					hr = DeleteCRLFromResultPane (pCRL, pDataObject);
					if ( SUCCEEDED (hr) )
						pCRL->GetCertStore ().Commit ();
				}
				else
					hr = E_FAIL;
			}
		}
		break;

	case CERTMGR_CTL:
		{
			CCTL* pCTL = reinterpret_cast <CCTL*> (pCookie);
			ASSERT (pCTL);
			if ( pCTL )
			{
				if ( bRequestConfirmation )
				{
					VERIFY (text.LoadString (IDS_CONFIRM_DELETE_CTL));
					VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
					hr = m_pConsole->MessageBox (text, caption, MB_ICONWARNING | MB_YESNO, &iRetVal);
					ASSERT (SUCCEEDED (hr));
				}

				if ( IDYES == iRetVal )
				{
                          CWaitCursor waitCursor;
					hr = QueryComponentDataRef ().DeleteCTLFromResultPane (pCTL,
							pDataObject);
					if ( SUCCEEDED (hr) )
					{
						pCTL->GetCertStore ().Commit ();
					}
				}
				else
					hr = E_FAIL;
			}
		}
		break;

	case CERTMGR_AUTO_CERT_REQUEST:
		{
			CAutoCertRequest* pACR = reinterpret_cast <CAutoCertRequest*> (pCookie);
			ASSERT (pACR);
			if ( pACR )
			{
				if ( bRequestConfirmation )
				{
					VERIFY (text.LoadString (IDS_CONFIRM_DELETE_ACR));
					VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
					hr = m_pConsole->MessageBox (text, caption, MB_ICONWARNING | MB_YESNO, &iRetVal);
					ASSERT (SUCCEEDED (hr));
				}

				if ( IDYES == iRetVal )
				{
					hr = QueryComponentDataRef ().DeleteCTLFromResultPane (pACR,
							pDataObject);
					if ( SUCCEEDED (hr) )
					{
						pACR->GetCertStore ().Commit ();
					}
				}
				else
					hr = E_FAIL;
			}
		}
		break;

    case CERTMGR_SAFER_COMPUTER_ENTRY:
    case CERTMGR_SAFER_USER_ENTRY:
		{
			CSaferEntry* pSaferEntry = reinterpret_cast <CSaferEntry*> (pCookie);
			ASSERT (pSaferEntry);
			if ( pSaferEntry )
			{
				if ( bRequestConfirmation )
				{
					if ( bIsMultipleSelect )
						VERIFY (text.LoadString (IDS_CONFIRM_DELETE_MULTI_SAFER_ENTRY));
					else
						VERIFY (text.LoadString (IDS_CONFIRM_DELETE_SAFER_ENTRY));

                    VERIFY (caption.LoadString (IDS_SAFER_WINDOWS_NODE_NAME));
					hr = m_pConsole->MessageBox (text, caption, MB_ICONWARNING | MB_YESNO, &iRetVal);
					ASSERT (SUCCEEDED (hr));
				}

				if ( IDYES == iRetVal )
				{
                    CWaitCursor waitCursor;

					hr = DeleteSaferEntryFromResultPane (pSaferEntry, pDataObject, bDoCommit);
				}
				else
					hr = E_FAIL;
			}
		}
        break;

	default:
		ASSERT (0);
		hr = E_UNEXPECTED;
		break;
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::DeleteCookie: 0x%x\n", hr);
	return hr;
}


HRESULT CCertMgrComponent::OnNotifyDelete (LPDATAOBJECT pDataObject)
{
	_TRACE (1, L"Entering CCertMgrComponent::OnNotifyDelete\n");
	ASSERT (pDataObject);
	if ( !pDataObject )
		return E_POINTER;

	HRESULT			hr = S_OK;
	CCertMgrCookie* pCookie =
			QueryComponentDataRef ().ConvertCookie (pDataObject);
	if ( pCookie )
	{
        CWaitCursor waitCursor;
		if ( ((CCertMgrCookie*) MMC_MULTI_SELECT_COOKIE) == pCookie )
		{

			// Is multiple select, get all selected items and paste each one
			CCertMgrDataObject* pDO = reinterpret_cast <CCertMgrDataObject*>(pDataObject);
			ASSERT (pDO);
			if ( pDO )
			{
				// Is multiple select, get all selected items and delete - confirm
				// first deletion only.  Don't commit until all are deleted.
				bool	    bRequestConfirmation = true;

                CCertStore* pCertStore = 0;
                // NTRAID# 129428	Cert UI: Cert snapin: Deleting large 
                // number of certificates from the stores takes over 3 minutes
                // Change this to false to do commit only at end.
                bool        bDoCommit = false;

				pDO->Reset();
				while (pDO->Next(1, reinterpret_cast<MMC_COOKIE*>(&pCookie), NULL) != S_FALSE &&
						SUCCEEDED (hr) )
				{
                    if ( pCookie->HasOpenPropertyPages () )
                    {
		                CString text;
		                CString	caption;

		                VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
		                text.FormatMessage (IDS_CANT_DELETE_OBJECT_PAGES_OPEN, 
				                pCookie->GetObjectName ()); 
		                int		iRetVal = 0;
		                VERIFY (SUCCEEDED (m_pConsole->MessageBox (text, caption,
				                MB_OK, &iRetVal)));
                        hr = E_FAIL;
                        break;
                    }
                }

                if ( SUCCEEDED (hr) )
                {
                    // If this is the store view, don't commit with each delete but commit
                    // all at once at the end.
				    pDO->Reset();
				    while (pDO->Next(1, reinterpret_cast<MMC_COOKIE*>(&pCookie), NULL) != S_FALSE &&
						    SUCCEEDED (hr) )
				    {
                        if ( bRequestConfirmation ) // first time through
                        {
                            if ( CERTMGR_SAFER_COMPUTER_ENTRY == pCookie->m_objecttype ||
                                    CERTMGR_SAFER_USER_ENTRY == pCookie->m_objecttype )
                            {
                            }
                            // Get the affected store.  The store is the same for all the
                            // certs in the list if the view mode is by store
                            else if ( IDM_STORE_VIEW == QueryComponentDataRef ().m_activeViewPersist )
                            {
                                bDoCommit = false;
                                switch (pCookie->m_objecttype)
                                {
                                case CERTMGR_CERTIFICATE:
                                    {
                                        CCertificate* pCert = dynamic_cast<CCertificate*> (pCookie);
                                        if ( pCert )
                                        {
                                            pCertStore = pCert->GetCertStore ();
                                        }
                                    }
                                    break;

                                case CERTMGR_CRL:
                                    {
                                        CCRL* pCRL = dynamic_cast<CCRL*> (pCookie);
                                        if ( pCRL )
                                            pCertStore = &(pCRL->GetCertStore ());
                                    }
                                    break;

                                case CERTMGR_CTL:
                                    {
                                        CCTL* pCTL = dynamic_cast<CCTL*> (pCookie);
                                        if ( pCTL )
                                            pCertStore = &(pCTL->GetCertStore ());
                                    }
                                    break;

                                case CERTMGR_AUTO_CERT_REQUEST:
                                    {
                                        CAutoCertRequest* pAutoCertReq = dynamic_cast <CAutoCertRequest*> (pCookie);
                                        if ( pAutoCertReq )
                                            pCertStore = &(pAutoCertReq->GetCertStore ());
                                    }
                                    break;

                                default:
                                    ASSERT (0);
                                    break;
                                }
                            }
                        }

    					hr = DeleteCookie (pCookie, pDataObject, bRequestConfirmation, true, bDoCommit);
	    				bRequestConfirmation = false;
				    }


                    if ( pCertStore )
                    {
    			        hr = pCertStore->Commit ();
    			        if ( SUCCEEDED (hr) )
    				        pCertStore->Resync ();
                    }
                    else if ( QueryComponentDataRef ().m_pGPEInformation && 
                        (CERTMGR_SAFER_COMPUTER_ENTRY == pCookie->m_objecttype ||
                        CERTMGR_SAFER_USER_ENTRY == pCookie->m_objecttype ) )
                    {
                        hr = QueryComponentDataRef ().m_pGPEInformation->PolicyChanged (
                                CERTMGR_SAFER_COMPUTER_ENTRY == pCookie->m_objecttype ? TRUE : FALSE,
                                FALSE, &g_guidExtension, &g_guidSnapin);
                        hr = QueryComponentDataRef ().m_pGPEInformation->PolicyChanged (
                                CERTMGR_SAFER_COMPUTER_ENTRY == pCookie->m_objecttype ? TRUE : FALSE,
                                FALSE, &g_guidRegExt, &g_guidSnapin);
                    }
                }
			}
		}
		else
		{
            if ( pCookie->HasOpenPropertyPages () )
            {
		        CString text;
		        CString	caption;

		        VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
		        text.FormatMessage (IDS_CANT_DELETE_OBJECT_PAGES_OPEN, 
				        pCookie->GetObjectName ()); 
		        int		iRetVal = 0;
		        VERIFY (SUCCEEDED (m_pConsole->MessageBox (text, caption,
				        MB_OK, &iRetVal)));
                hr = E_FAIL;
            }
            else
            {
			    // If m_pPastedDO == pDataObject then this delete is the
			    // result of a paste.
			    // In that event, we don't want a confirmation message.
			    hr = DeleteCookie (pCookie, pDataObject, m_pPastedDO != pDataObject, false, true);
            }
		}
	}

	if ( m_pPastedDO == pDataObject )
		m_pPastedDO = 0;

//    if ( SUCCEEDED (hr) )
//	    hr = m_pConsole->UpdateAllViews (pDataObject, 0, 0);

    _TRACE (-1, L"Leaving CCertMgrComponent::OnNotifyDelete: 0x%x\n", hr);
	return hr;
}


HRESULT CCertMgrComponent::DeleteCertFromResultPane (
        CCertificate * pCert, 
        LPDATAOBJECT pDataObject, 
        bool bDoCommit)
{
	_TRACE (1, L"Entering CCertMgrComponent::DeleteCertFromResultPane\n");
	HRESULT			hr = S_OK;
	if ( pCert->DeleteFromStore (bDoCommit) )
	{
        if ( IDM_USAGE_VIEW == QueryComponentDataRef ().m_activeViewPersist && m_pLastUsageCookie )
        {
            m_pLastUsageCookie->SetCertCount (m_pLastUsageCookie->GetCertCount () - 1);
        }
		HRESULTITEM	itemID;
		hr = m_pResultData->FindItemByLParam ( (LPARAM) pCert, &itemID);
		if ( SUCCEEDED (hr) )
		{
			hr = m_pResultData->DeleteItem (itemID, 0);
		}

		// If we can't succeed in removing this one item, then update the whole panel.
		if ( !SUCCEEDED (hr) )
		{
			hr = m_pConsole->UpdateAllViews (pDataObject, 0, 0);
		}
	}
	else
	{
		DWORD	dwErr = GetLastError ();
		CString text;
		CString	caption;
        CCertStore* pStore = pCert->GetCertStore ();

        if ( pStore )
        {
		    VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
		    text.FormatMessage (IDS_CANT_DELETE_CERT_FROM_SYSTEM_STORE, 
				    pStore->GetLocalizedName (), 
				    GetSystemMessage (dwErr));
		    int		iRetVal = 0;
		    VERIFY (SUCCEEDED (m_pConsole->MessageBox (text, caption,
				    MB_OK, &iRetVal)));
        }
		hr = HRESULT_FROM_WIN32 (dwErr);
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::DeleteCertFromResultPane: 0x%x\n", hr);
	return hr;
}

HRESULT CCertMgrComponent::DeleteCRLFromResultPane (CCRL * pCRL, LPDATAOBJECT pDataObject)
{
	_TRACE (1, L"Entering CCertMgrComponent::DeleteCRLFromResultPane\n");
	HRESULT			hr = S_OK;
	if ( pCRL->DeleteFromStore () )
	{
		hr = pCRL->GetCertStore ().Commit ();
		ASSERT (SUCCEEDED (hr));
		if ( SUCCEEDED (hr) )
		{
			HRESULTITEM	itemID;
			hr = m_pResultData->FindItemByLParam ( (LPARAM) pCRL, &itemID);
			if ( SUCCEEDED (hr) )
			{
				hr = m_pResultData->DeleteItem (itemID, 0);
			}
            else
            {
                _TRACE (0, L"IResultData::FindItemByLParam () failed: 0x%x (%s)\n",
                        hr, (PCWSTR) GetSystemMessage (hr));
            }

			// If we can't succeed in removing this one item, then update the whole panel.
			if ( !SUCCEEDED (hr) )
			{
				hr = m_pConsole->UpdateAllViews (pDataObject, 0, 0);
			}
		}
	}
	else
	{
		DisplayAccessDenied ();
	}
	_TRACE (-1, L"Leaving CCertMgrComponent::DeleteCRLFromResultPane: 0x%x\n", hr);
	return hr;
}

typedef struct _ENUM_ARG {
     DWORD					dwFlags;
	CCertMgrComponent*		m_pComp;
	LPCWSTR					m_pcszMachineName;
	LPCONSOLE				m_pConsole;
} ENUM_ARG, *PENUM_ARG;

static BOOL WINAPI EnumIComponentSysCallback (
     IN const void* pwszSystemStore,
     IN DWORD dwFlags,
     IN PCERT_SYSTEM_STORE_INFO /*pStoreInfo*/,
     IN OPTIONAL void* /*pvReserved*/,
     IN OPTIONAL void* pvArg
     )
{
	_TRACE (1, L"Entering EnumIComponentSysCallback\n");
     PENUM_ARG pEnumArg = (PENUM_ARG) pvArg;

	// Create new cookies
	SPECIAL_STORE_TYPE	storeType = GetSpecialStoreType ((LPWSTR) pwszSystemStore);

	if ( pEnumArg->m_pComp->QueryComponentDataRef ().ShowArchivedCerts () )
		dwFlags |= CERT_STORE_ENUM_ARCHIVED_FLAG;

	//
	// We will not expose the ACRS store for machines or users.  It is not
	// interesting or useful at this level.  All Auto Cert Requests should
	// be managed only at the policy level.
	//
	if ( ACRS_STORE != storeType )
	{
		CCertStore* pNewCookie = new CCertStore (
				CERTMGR_LOG_STORE,
				CERT_STORE_PROV_SYSTEM,
				dwFlags,
				pEnumArg->m_pcszMachineName,
				(LPCWSTR) pwszSystemStore,
				(LPCWSTR) pwszSystemStore,
				_T (""),
				storeType,
				dwFlags,
				pEnumArg->m_pConsole);
		if ( pNewCookie )
			pEnumArg->m_pComp->m_usageStoreList.AddTail (pNewCookie);
	}

	_TRACE (-1, L"Leaving EnumIComponentSysCallback\n");
     return TRUE;
}



HRESULT CCertMgrComponent::EnumerateLogicalStores (CCertMgrCookie& parentCookie)
{
	_TRACE (1, L"Entering CCertMgrComponent::EnumerateLogicalStores\n");
	CWaitCursor				cursor;
	HRESULT					hr = S_OK;
     ENUM_ARG				enumArg;
	CCertMgrComponentData&	compData = QueryComponentDataRef ();
     DWORD					dwFlags = compData.GetLocation ();

      ::ZeroMemory (&enumArg, sizeof (enumArg));
     enumArg.dwFlags = dwFlags;
	enumArg.m_pComp = this;
	enumArg.m_pcszMachineName = parentCookie.QueryNonNULLMachineName ();
	enumArg.m_pConsole = m_pConsole;
	CString	location;
	void*	pvPara = 0;

    // empty out the store list first
	CCertStore*	pCertStore = 0;
	while (!m_usageStoreList.IsEmpty () )
	{
		pCertStore = m_usageStoreList.RemoveHead ();
		ASSERT (pCertStore);
		if ( pCertStore )
        {
            pCertStore->SetDirty ();
            pCertStore->Commit ();
            pCertStore->Release ();
        }
	}

	if ( !compData.GetManagedService ().IsEmpty () )
	{
		if ( !compData.GetManagedComputer ().IsEmpty () )
		{
			location = compData.GetManagedComputer () + _T("\\") +
					compData.GetManagedComputer ();
			pvPara = (void *) (LPCWSTR) location;
		}
		else
			pvPara = (void *) (LPCWSTR) compData.GetManagedService ();
	}
	else if ( !compData.GetManagedComputer ().IsEmpty () )
	{
		pvPara = (void *) (LPCWSTR) compData.GetManagedComputer ();
	}

	CString	fileName = compData.GetCommandLineFileName ();
	if ( fileName.IsEmpty () )
	{
		// Ensure creation of MY store
		HCERTSTORE hTempStore = ::CertOpenStore (CERT_STORE_PROV_SYSTEM,
				X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, NULL,
				dwFlags | CERT_STORE_SET_LOCALIZED_NAME_FLAG,
				MY_SYSTEM_STORE_NAME);
		if ( hTempStore )  // otherwise, store is read only
		{
			VERIFY (::CertCloseStore (hTempStore, CERT_CLOSE_STORE_CHECK_FLAG));
		}
		else
		{
			_TRACE (0, L"CertOpenStore (%s) failed: 0x%x\n", 
					MY_SYSTEM_STORE_NAME, GetLastError ());		
		}

		if ( !::CertEnumSystemStore (dwFlags, pvPara, &enumArg,
				EnumIComponentSysCallback) )
		{
			DWORD	dwErr = GetLastError ();
			CString text;
			CString	caption;

			VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
			if ( ERROR_ACCESS_DENIED == dwErr )
			{
				VERIFY (text.LoadString (IDS_NO_PERMISSION));

			}
			else
			{
				text.FormatMessage (IDS_CANT_ENUMERATE_SYSTEM_STORES, GetSystemMessage (dwErr));
			}
			int		iRetVal = 0;
			VERIFY (SUCCEEDED (m_pConsole->MessageBox (text, caption,
					MB_OK, &iRetVal)));
			hr = HRESULT_FROM_WIN32 (dwErr);
		}
	}
	else
	{
		// Create new cookies

		CCertStore* pNewCookie = new CCertStore (
				CERTMGR_LOG_STORE,
				CERT_STORE_PROV_FILENAME_W,
				0, //dwFlags,
				parentCookie.QueryNonNULLMachineName (),
				fileName, fileName, _T (""), NO_SPECIAL_TYPE,
				QueryComponentDataRef ().GetLocation (),
				m_pConsole);
		if ( pNewCookie )
			m_usageStoreList.AddTail (pNewCookie);
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::EnumerateLogicalStores: 0x%x\n", hr);
	return hr;
}


HRESULT CCertMgrComponent::EnumCertsByUsage (CUsageCookie * pUsageCookie)
{
	_TRACE (1, L"Entering CCertMgrComponent::EnumCertsByUsage\n");
	ASSERT (pUsageCookie);
	if ( !pUsageCookie )
		return E_POINTER;
	CCertMgrComponentData&	compData = QueryComponentDataRef ();

	HRESULT hr = m_pResultData->DeleteAllRsltItems ();
	if ( SUCCEEDED (hr) )
	{
		compData.RemoveResultCookies (m_pResultData);
	}

	if ( m_bShowArchivedCertsStateWhenLogStoresEnumerated !=
			compData.ShowArchivedCerts () )
	{
		m_bShowArchivedCertsStateWhenLogStoresEnumerated =
				compData.ShowArchivedCerts ();
		m_bUsageStoresEnumerated = false;
		CloseAndReleaseUsageStores ();
	}
	// Enumerate system stores, if not already done
	if ( !m_bUsageStoresEnumerated && pUsageCookie )
	{
		hr = EnumerateLogicalStores (*pUsageCookie);
		m_bUsageStoresEnumerated = true;
	}


	// Iterate through stores and find certs for given Oid.
	CCertStore*	pCertStore = 0;
	CCookie&	rootCookie = compData.QueryBaseRootCookie ();
	int			nCertCount = 0;

	for (POSITION pos = m_usageStoreList.GetHeadPosition (); pos; )
	{
		pCertStore = m_usageStoreList.GetNext (pos);
		ASSERT (pCertStore);
		if ( pCertStore )
		{
			int		nOIDCount = pUsageCookie->GetOIDCount ();
			ASSERT (nOIDCount > 0);
			if ( nOIDCount <= 0 )
				continue;

			CERT_ENHKEY_USAGE	enhKeyUsage;
			enhKeyUsage.cUsageIdentifier = nOIDCount;
			enhKeyUsage.rgpszUsageIdentifier = new LPSTR [nOIDCount];
			if ( enhKeyUsage.rgpszUsageIdentifier )
			{
				for (int nIndex = 0; nIndex < nOIDCount; nIndex++)
				{
					enhKeyUsage.rgpszUsageIdentifier[nIndex] =
							 (!nIndex) ?
							pUsageCookie->GetFirstOID () :
							pUsageCookie->GetNextOID ();
				}

				PCCERT_CONTEXT	pPrevCertContext = 0;
				PCCERT_CONTEXT	pCertContext = 0;
				CCertificate*	pCert = 0;
				DWORD			dwErr = 0;
				RESULTDATAITEM	rdItem;
				void*			pvPara = (void *) &enhKeyUsage;

				::ZeroMemory (&rdItem, sizeof (rdItem));
				rdItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM;
				rdItem.nImage = iIconCertificate;
				rdItem.nCol = 0;

				bool	bDone = false;
				while ( !bDone )
				{
					pCertContext = pCertStore->FindCertificate (
							CERT_FIND_VALID_ENHKEY_USAGE_FLAG |
								CERT_FIND_OPTIONAL_ENHKEY_USAGE_FLAG, // | CERT_FIND_OR_ENHKEY_USAGE_FLAG ,
							CERT_FIND_ENHKEY_USAGE,
							pvPara,
 							pPrevCertContext);
					if ( !pCertContext )
					{
						dwErr = GetLastError ();
						switch (dwErr)
						{
						case CRYPT_E_NOT_FOUND:	// We're done.  No more certificates.
							break;

						case 0:		// no error to display
							break;

                        case E_INVALIDARG:
                            if ( !pCertStore->GetStoreHandle () )
                            {
					            CString	text;
					            CString caption;
					            int		iRetVal = IDNO;

					            text.FormatMessage 
                                        (IDS_CANNOT_OPEN_CERT_STORE_TO_FIND_CERT_BY_PURPOSE,
                                        pCertStore->GetLocalizedName ());
					            VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
					            hr = m_pConsole->MessageBox (text, caption,
							            MB_ICONWARNING | MB_OK, &iRetVal);
                                break;
                            }
                            // fall through

						default:
							compData.DisplaySystemError (dwErr);
							break;
						}
						bDone = true;
						continue;
					}
					pCert =
						new CCertificate (pCertContext, pCertStore);

					if ( !pCert )
					{
						// Do this twice.  Must reduce ref count by 2
						::CertFreeCertificateContext (pCertContext);
						::CertFreeCertificateContext (pCertContext);
						hr = E_OUTOFMEMORY;
						break;
					}
					nCertCount++;

					rootCookie.m_listResultCookieBlocks.AddHead (pCert);
					rdItem.str = MMC_CALLBACK;
					rdItem.lParam = (LPARAM) pCert;
					pCert->m_resultDataID = m_pResultData;
					hr = m_pResultData->InsertItem (&rdItem);
					ASSERT (SUCCEEDED (hr));


					pPrevCertContext = pCertContext;
				}
				pCertStore->Close ();
				delete [] enhKeyUsage.rgpszUsageIdentifier;
			}
			else
			{
				hr = E_OUTOFMEMORY;
				break;
			}
		}
	}

	pUsageCookie->SetCertCount (nCertCount);
    hr = DisplayCertificateCountByUsage (
            pUsageCookie->GetObjectName (),
            pUsageCookie->GetCertCount ());
	_TRACE (-1, L"Leaving CCertMgrComponent::EnumCertsByUsage: 0x%x\n", hr);
	return hr;
}


// This compare is used to sort the items in the listview
//
// Parameters:
//
// lUserParam - user param passed in when IResultData::Sort () was called
// cookieA - first item to compare
// cookieB - second item to compare
// pnResult [in, out]- contains the col on entry,
//             -1, 0, 1 based on comparison for return value.
//
// Note: Assume sort is ascending when comparing.

STDMETHODIMP CCertMgrComponent::Compare (
        LPARAM /*lUserParam*/, 
        MMC_COOKIE cookieA, 
        MMC_COOKIE cookieB, 
        int* pnResult)
{
	HRESULT					hr = S_OK;

    if ( pnResult && cookieA && cookieB )
	{
		int	     colNum = *pnResult;

        if ( CERTMGR_MULTISEL == m_currResultNodeType )
        {
			CCertMgrCookie*	pCookie = reinterpret_cast<CCertMgrCookie*> (cookieA);
            if ( pCookie )
            {
                switch (pCookie->m_objecttype)
                {
                case CERTMGR_CERTIFICATE:
                    m_currResultNodeType = CERTMGR_CERTIFICATE;
                    break;

                case CERTMGR_CTL:
                    m_currResultNodeType = CERTMGR_CTL;
                    break;

                case CERTMGR_CRL: 
                    m_currResultNodeType = CERTMGR_CRL;
                    break;

                default:
                    break;
                }
			}
        }

		CCertMgrCookie* pCookieA = reinterpret_cast <CCertificate*> (cookieA);
		CCertMgrCookie* pCookieB = reinterpret_cast <CCertificate*> (cookieB);

		switch (m_currResultNodeType)
		{
		case CERTMGR_CERTIFICATE:
			{
                ASSERT (CERTMGR_CERTIFICATE == pCookieA->m_objecttype &&
                    CERTMGR_CERTIFICATE == pCookieB->m_objecttype);
                if ( CERTMGR_CERTIFICATE == pCookieA->m_objecttype &&
                    CERTMGR_CERTIFICATE == pCookieB->m_objecttype )
                {
                    m_nSelectedCertColumn = colNum;
				    CCertificate* pCertA = reinterpret_cast <CCertificate*> (cookieA);
				    CCertificate* pCertB = reinterpret_cast <CCertificate*> (cookieB);
				    switch ( colNum )
				    {
				    case COLNUM_CERT_SUBJECT:
                        *pnResult = LocaleStrCmp (pCertA->GetSubjectName (),
                                pCertB->GetSubjectName ());
					    break;

				    case COLNUM_CERT_ISSUER:
					    *pnResult = LocaleStrCmp (pCertA->GetIssuerName (),
                                pCertB->GetIssuerName ());
					    break;

				    case COLNUM_CERT_EXPIRATION_DATE:
					    *pnResult = pCertA->CompareExpireDate (*pCertB);
					    break;

				    case COLNUM_CERT_PURPOSE:
					    *pnResult = LocaleStrCmp (pCertA->GetEnhancedKeyUsage (),
                                         pCertB->GetEnhancedKeyUsage ());
					    break;

				    case COLNUM_CERT_CERT_NAME:
					    *pnResult = LocaleStrCmp (pCertA->GetFriendlyName (),
                                         pCertB->GetFriendlyName ());
					    break;

                    case COLNUM_CERT_STATUS:
                        *pnResult = LocaleStrCmp (pCertA->FormatStatus (), 
                                pCertB->FormatStatus ());
                        break;

                    // NTRAID# 247237	Cert UI: Cert Snapin: Certificates snapin should show  template name
                    case COLNUM_CERT_TEMPLATE:
                        *pnResult = LocaleStrCmp (pCertA->GetTemplateName (), 
                                pCertB->GetTemplateName ());
                        break;

				    default:
					    ASSERT (0);
					    break;
				    }
                }
			}
			break;

		case CERTMGR_CRL:
			{
                ASSERT (CERTMGR_CRL == pCookieA->m_objecttype &&
                    CERTMGR_CRL == pCookieB->m_objecttype);
                if ( CERTMGR_CRL == pCookieA->m_objecttype &&
                    CERTMGR_CRL == pCookieB->m_objecttype )
                {
                    m_nSelectedCRLColumn = colNum;
				    CCRL* pCRLA = reinterpret_cast <CCRL*> (cookieA);
				    CCRL* pCRLB = reinterpret_cast <CCRL*> (cookieB);
				    switch ( colNum )
				    {
				    case COLNUM_CRL_EFFECTIVE_DATE:
					    *pnResult = pCRLA->CompareEffectiveDate (*pCRLB);
					    break;

				    case COLNUM_CRL_ISSUER:
					    *pnResult = LocaleStrCmp (pCRLA->GetIssuerName (),
                                         pCRLB->GetIssuerName ());
					    break;

				    case COLNUM_CRL_NEXT_UPDATE:
					    *pnResult = pCRLA->CompareNextUpdate (*pCRLB);
					    break;

				    default:
					    ASSERT (0);
					    break;
				    }
                }
			}
			break;

		case CERTMGR_CTL:
			{
                ASSERT (CERTMGR_CTL == pCookieA->m_objecttype &&
                    CERTMGR_CTL == pCookieB->m_objecttype);
                if ( CERTMGR_CTL == pCookieA->m_objecttype &&
                    CERTMGR_CTL == pCookieB->m_objecttype )
                {
                    m_nSelectedCTLColumn = colNum;
				    CCTL* pCTLA = reinterpret_cast <CCTL*> (cookieA);
				    CCTL* pCTLB = reinterpret_cast <CCTL*> (cookieB);
				    switch ( colNum )
				    {
				    case COLNUM_CTL_ISSUER:
					    *pnResult = LocaleStrCmp (pCTLA->GetIssuerName (),
                                         pCTLB->GetIssuerName ());
					    break;

				    case COLNUM_CTL_EFFECTIVE_DATE:
					    *pnResult = pCTLA->CompareEffectiveDate (*pCTLB);
					    break;

				    case COLNUM_CTL_PURPOSE:
					    *pnResult = LocaleStrCmp (pCTLA->GetPurpose (),
                                         pCTLB->GetPurpose ());
					    break;

				    case COLNUM_CTL_FRIENDLY_NAME:
				    default:
					    ASSERT (0);
					    break;
				    }
                }
			}
			break;

		case CERTMGR_AUTO_CERT_REQUEST:
			{
                ASSERT (CERTMGR_AUTO_CERT_REQUEST == pCookieA->m_objecttype &&
                    CERTMGR_AUTO_CERT_REQUEST == pCookieB->m_objecttype);
                if ( CERTMGR_AUTO_CERT_REQUEST == pCookieA->m_objecttype &&
                    CERTMGR_AUTO_CERT_REQUEST == pCookieB->m_objecttype )
                {
				    CAutoCertRequest* pAutoCertA = reinterpret_cast <CAutoCertRequest*> (cookieA);
				    CAutoCertRequest* pAutoCertB = reinterpret_cast <CAutoCertRequest*> (cookieB);
				    switch ( colNum )
				    {
				    case 0:
					    {
                            CString strA;
                            CString strB;

						    VERIFY (SUCCEEDED (pAutoCertA->GetCertTypeName (strA)));
						    VERIFY (SUCCEEDED (pAutoCertB->GetCertTypeName (strB)));
                                    *pnResult = LocaleStrCmp (strA, strB);
					    }
					    break;

				    default:
					    ASSERT (0);
					    break;
				    }
                }
			}

        case CERTMGR_SAFER_COMPUTER_ENTRY:
        case CERTMGR_SAFER_USER_ENTRY:
            {
                CSaferEntry* pSaferEntryA = reinterpret_cast <CSaferEntry*> (cookieA);
                CSaferEntry* pSaferEntryB = reinterpret_cast <CSaferEntry*> (cookieB);
                m_nSelectedSaferEntryColumn = colNum;
                switch (colNum)
                {
                case COLNUM_SAFER_ENTRIES_NAME:
                    *pnResult = LocaleStrCmp (pSaferEntryA->GetObjectName (),
                            pSaferEntryB->GetObjectName ());
                    break;

                case COLNUM_SAFER_ENTRIES_TYPE:
                    *pnResult = LocaleStrCmp (pSaferEntryA->GetTypeString (),
                            pSaferEntryB->GetTypeString ());
                    break;

                case COLNUM_SAFER_ENTRIES_LEVEL:
                    *pnResult = LocaleStrCmp (pSaferEntryA->GetLevelFriendlyName (),
                            pSaferEntryB->GetLevelFriendlyName ());
                    break;

                case COLNUM_SAFER_ENTRIES_DESCRIPTION:
                    *pnResult = LocaleStrCmp (pSaferEntryA->GetDescription (),
                            pSaferEntryB->GetDescription ());
                    break;

                case COLNUM_SAFER_ENTRIES_LAST_MODIFIED_DATE:
                    *pnResult = pSaferEntryA->CompareLastModified (*pSaferEntryB);
                    break;
               }
            }
            break;

		default:
			break;
		}
	}
	
	return hr;
}


HRESULT CCertMgrComponent::EnumCTLs (CCertStore& rCertStore)
{
	_TRACE (1, L"Entering CCertMgrComponent::EnumCTLs\n");
	CCertMgrComponentData&	compdata = QueryComponentDataRef ();
	RESULTDATAITEM			rdItem;
	CWaitCursor				cursor;
     PCCTL_CONTEXT			pCTLContext = 0;
	HRESULT					hr = 0;
	CCTL*					pCTL = 0;
	CCookie&				rootCookie = compdata.QueryBaseRootCookie ();
	CTypedPtrList<CPtrList, CCertStore*> storeList;

	// Only enumerate the logical stores if this is not the GPE or RSOP.  If it is the
	// GPE, add the Trust and Root store.
	if ( !compdata.m_pGPEInformation && !compdata.m_bIsRSOP )
	{
		hr = compdata.EnumerateLogicalStores (&storeList);
		ASSERT (SUCCEEDED (hr));
	}
	else
	{
		if ( compdata.m_pGPERootStore )
		{
			compdata.m_pGPERootStore->AddRef ();
			storeList.AddTail (compdata.m_pGPERootStore);
		}
		if ( compdata.m_pGPETrustStore )
		{
			compdata.m_pGPETrustStore->AddRef ();
			storeList.AddTail (compdata.m_pGPETrustStore);
		}
	}
	if ( compdata.m_pFileBasedStore )
	{
		compdata.m_pFileBasedStore->AddRef ();
		storeList.AddTail (compdata.m_pFileBasedStore);
	}

	::ZeroMemory (&rdItem, sizeof (rdItem));
	rdItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM;
	rdItem.nCol = 0;	// Must always be 0
	while ( 1 )
	{
		pCTLContext = rCertStore.EnumCTLs (pCTLContext);
		if ( !pCTLContext )
			break;
		if ( ACRS_STORE == rCertStore.GetStoreType () )
		{
			pCTL =
				new CAutoCertRequest (pCTLContext, rCertStore);
		}
		else
		{
			pCTL =
				new CCTL (pCTLContext, rCertStore, CERTMGR_CTL, &storeList);
		}
		if ( !pCTL )
		{
			hr = E_OUTOFMEMORY;
			break;
		}

		if ( ACRS_STORE != rCertStore.GetStoreType () )
			rdItem.nImage = iIconCTL;
		else
			rdItem.nImage = 0;

		rootCookie.m_listResultCookieBlocks.AddHead (pCTL);
		rdItem.str = MMC_TEXTCALLBACK;
		rdItem.lParam = (LPARAM) pCTL;
		pCTL->m_resultDataID = m_pResultData;
		hr = m_pResultData->InsertItem (&rdItem);
		ASSERT (SUCCEEDED (hr));
	}
	rCertStore.Close ();

	CCertStore* pStore = 0;

	// Clean up store list
	while (!storeList.IsEmpty () )
	{
		pStore = storeList.RemoveHead ();
		ASSERT (pStore);
		if ( pStore )
		{
			pStore->Close ();
			pStore->Release ();
		}
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::EnumCTLs: 0x%x\n", hr);
	return hr;
}


STDMETHODIMP CCertMgrComponent::Notify (LPDATAOBJECT pDataObject, MMC_NOTIFY_TYPE event, LPARAM arg, LPARAM param)
{
     _TRACE (1, L"Entering CCertMgrComponent::Notify\n");
     HRESULT hr = S_OK;

     switch (event)
     {
		case MMCN_CUTORMOVE:
			hr = OnNotifyCutOrMove (arg);
			break;

		case MMCN_QUERY_PASTE:
			hr = OnNotifyQueryPaste (pDataObject, arg, param);
			break;

		case MMCN_PASTE:
			hr = OnNotifyPaste (pDataObject, arg, param);
			break;

	     case MMCN_SHOW:
			// CODEWORK this is hacked together quickly
			{
				CCookie* pCookie = NULL;
				hr = ExtractData (pDataObject,
								  CDataObject::m_CFRawCookie,
								  &pCookie,
								  sizeof(pCookie));
				if ( SUCCEEDED (hr) )
				{
					hr = Show (ActiveBaseCookie (pCookie), arg,
							(HSCOPEITEM) param, pDataObject);
				}
			}
			break;

        case MMCN_CANPASTE_OUTOFPROC:
            hr = OnNotifyCanPasteOutOfProc (reinterpret_cast<LPBOOL>(param));
            break;

		default:
			hr = CComponent::Notify (pDataObject, event, arg, param);
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::Notify: 0x%x\n", hr);
	return hr;
}


void CCertMgrComponent::DisplayAccessDenied ()
{
	_TRACE (1, L"Entering CCertMgrComponent::DisplayAccessDenied\n");
	DWORD	dwErr = GetLastError ();
	ASSERT (E_ACCESSDENIED == dwErr);
	if ( E_ACCESSDENIED == dwErr )
	{
		LPVOID lpMsgBuf;
			
		FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
				NULL,
				GetLastError (),
				MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
				 (LPWSTR) &lpMsgBuf,     0,     NULL );
			
		// Display the string.
		CString	caption;
		VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
		int		iRetVal = 0;
		VERIFY (SUCCEEDED (m_pConsole->MessageBox ( (LPWSTR) lpMsgBuf, caption,
			MB_ICONWARNING | MB_OK, &iRetVal)));

		// Free the buffer.
		LocalFree (lpMsgBuf);
	}
	_TRACE (-1, L"Leaving CCertMgrComponent::DisplayAccessDenied\n");
}

HRESULT CCertMgrComponent::OnNotifyPaste (LPDATAOBJECT pDataObject, LPARAM arg, LPARAM param)
{
	_TRACE (1, L"Entering CCertMgrComponent::OnNotifyPaste\n");
	ASSERT (pDataObject && arg);
	if ( !pDataObject || !arg )
		return E_POINTER;

	HRESULT					hr = S_OK;
	CCertMgrComponentData&	dataRef = QueryComponentDataRef ();
	HSCOPEITEM				hScopeItem = -1;
	bool					bContainsCerts = false;
	bool					bContainsCTLs = false;
	bool					bContainsCRLs = false;

	CCertMgrCookie* pTargetCookie = dataRef.ConvertCookie (pDataObject);
	ASSERT (pTargetCookie);
	if ( pTargetCookie )
	{
		CCertStore*			pCertStore = 0;
		SPECIAL_STORE_TYPE	storeType = NO_SPECIAL_TYPE;

		switch (pTargetCookie->m_objecttype)
		{
		case CERTMGR_PHYS_STORE:
		case CERTMGR_LOG_STORE:
		case CERTMGR_LOG_STORE_GPE:
		case CERTMGR_LOG_STORE_RSOP:
			{
				pCertStore = reinterpret_cast <CCertStore*>
						(pTargetCookie);
				ASSERT (pCertStore);
				if ( pCertStore )
				{
					storeType = pCertStore->GetStoreType ();
					hScopeItem = pCertStore->m_hScopeItem;
					bContainsCerts = pCertStore->ContainsCertificates ();
					bContainsCRLs = pCertStore->ContainsCRLs ();
					bContainsCTLs = pCertStore->ContainsCTLs ();
					ASSERT (-1 != hScopeItem);
				}
				else
					hr = E_POINTER;
			}
			break;

		case CERTMGR_CRL_CONTAINER:
			{
				bContainsCRLs = true;
				CContainerCookie* pCont = reinterpret_cast <CContainerCookie*>
						(pTargetCookie);
				ASSERT (pCont);
				if ( pCont )
				{
					pCertStore = &(pCont->GetCertStore ());
					storeType = pCont->GetStoreType ();
				}
				else
					hr = E_POINTER;
			}
			break;

		case CERTMGR_CTL_CONTAINER:
			{
				bContainsCTLs = true;
				CContainerCookie* pCont = reinterpret_cast <CContainerCookie*>
						(pTargetCookie);
				ASSERT (pCont);
				if ( pCont )
				{
					pCertStore = &(pCont->GetCertStore ());
					storeType = pCont->GetStoreType ();
				}
				else
					hr = E_POINTER;
			}
			break;

		case CERTMGR_CERT_CONTAINER:
			{
				bContainsCerts = true;
				CContainerCookie* pCont = reinterpret_cast <CContainerCookie*>
						(pTargetCookie);
				ASSERT (pCont);
				if ( pCont )
				{
					pCertStore = &(pCont->GetCertStore ());
					storeType = pCont->GetStoreType ();
				}
				else
					hr = E_POINTER;
			}
			break;

		case CERTMGR_CERTIFICATE:
			{
				CCertificate* pCert = reinterpret_cast <CCertificate*> (pTargetCookie);
				ASSERT (pCert);
				if ( pCert )
				{
					pCertStore = pCert->GetCertStore ();
					storeType = pCert->GetStoreType ();
				}
				else
					hr = E_POINTER;
			}
			break;

		case CERTMGR_CRL:
			{
				CCRL* pCRL = reinterpret_cast <CCRL*> (pTargetCookie);
				ASSERT (pCRL);
				if ( pCRL )
				{
					pCertStore = &(pCRL->GetCertStore ());
				}
				else
					hr = E_POINTER;
			}
			break;

		case CERTMGR_CTL:
			{
				CCTL* pCTL = reinterpret_cast <CCTL*> (pTargetCookie);
				ASSERT (pCTL);
				if ( pCTL )
				{
					pCertStore = &(pCTL->GetCertStore ());
				}
				else
					hr = E_POINTER;
			}
			break;

        case CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS:
        case CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS:
            ASSERT (0);
            break;

        case CERTMGR_SAFER_COMPUTER_ENTRIES:
        case CERTMGR_SAFER_USER_ENTRIES:
            {
                param = 0; // do not allow cut/move of originating cert
                CSaferEntries* pSaferEntries = dynamic_cast <CSaferEntries*> (pTargetCookie);
                if ( pSaferEntries )
                {
                    CCertStore* pGPEStore = 0;
                    bool    bIsComputer = 
                        (CERTMGR_SAFER_COMPUTER_ENTRIES == pTargetCookie->m_objecttype);
                    DWORD dwDefaultLevelID = CSaferLevel::ReturnDefaultLevel (
                        dataRef.m_pGPEInformation, 
                        bIsComputer ? true : false, 
                        bIsComputer ? dataRef.m_rsopObjectArrayComputer : dataRef.m_rsopObjectArrayUser);

                    if ( SAFER_LEVELID_DISALLOWED== dwDefaultLevelID )
                        hr = pSaferEntries->GetTrustedPublishersStore (&pGPEStore);
                    else
                        hr = pSaferEntries->GetDisallowedStore (&pGPEStore);
                    if ( SUCCEEDED (hr) )
                    {
                        pCertStore = pGPEStore;
                    }
                }
            }
            break;

		default:
			hr = E_UNEXPECTED;
			break;
		}


		if ( !SUCCEEDED (hr) )
			return hr;

		CCertMgrCookie* pPastedCookie =
				dataRef.ConvertCookie ((LPDATAOBJECT) arg);
		if ( pPastedCookie && pCertStore )
		{
			if ( ((CCertMgrCookie*) MMC_MULTI_SELECT_COOKIE) == pPastedCookie )
			{
				LPDATAOBJECT*	ppDO = reinterpret_cast<LPDATAOBJECT*>((LPDATAOBJECT) param);
			     CCookiePtrArray	rgCookiesCopied;

				// Is multiple select, get all selected items and paste each one
				LPDATAOBJECT	pMSDO = (LPDATAOBJECT) arg;
				if ( pMSDO )
				{
					CCertMgrDataObject* pDO = reinterpret_cast <CCertMgrDataObject*>(pMSDO);
					ASSERT (pDO);
					if ( pDO )
					{
						bool			bRequestConfirmation = true;
						CCertMgrCookie*	pCookie = 0;
						pDO->Reset();
						while (pDO->Next(1, reinterpret_cast<MMC_COOKIE*>(&pCookie), NULL) != S_FALSE)
						{
							hr = PasteCookie (pCookie, pTargetCookie, *pCertStore,
									storeType, bContainsCerts, bContainsCRLs, bContainsCTLs,
									hScopeItem, bRequestConfirmation, true);
							if ( SUCCEEDED (hr) && ppDO && S_FALSE != hr )
								rgCookiesCopied.Add (pCookie);
                            else if ( FAILED (hr) )
                                break;
							bRequestConfirmation = false;
						}
					}
					else
						return E_UNEXPECTED;
				}
				else
					return E_UNEXPECTED;


				if ( pCertStore && SUCCEEDED (hr) )
				{
					pCertStore->Commit ();
				}
				else
					pCertStore->Resync ();

                if ( !bContainsCerts ) 
                {
                    // not necessary for certs - they're 
                    //added to the end
				    m_pConsole->UpdateAllViews (pDataObject, 0, HINT_PASTE_COOKIE);
                }

				if ( !ppDO )
					return S_OK;

				*ppDO = 0;



			     if ( rgCookiesCopied.GetSize () == 0 )
					return S_FALSE;

				CComObject<CCertMgrDataObject>* pObject = 0;
				hr = CComObject<CCertMgrDataObject>::CreateInstance(&pObject);
				ASSERT(SUCCEEDED(hr));
				if (FAILED(hr))
					return hr;

				ASSERT(pObject != NULL);
				if (pObject == NULL)
					return E_OUTOFMEMORY;

				hr = pObject->Initialize (
						pPastedCookie,
						CCT_UNINITIALIZED,
						FALSE,
						0,
						L"",
						L"",
						L"",
						dataRef);

				for (int i=0; i < rgCookiesCopied.GetSize(); ++i)
				{
					pObject->AddCookie(rgCookiesCopied[i]);
				}

				hr = pObject->QueryInterface(
						IID_PPV_ARG (IDataObject, ppDO));

				return hr;
			}
			else
			{
				hr = PasteCookie (pPastedCookie, pTargetCookie, *pCertStore,
						storeType, bContainsCerts, bContainsCRLs, bContainsCTLs,
						hScopeItem, true, false);
				if ( pCertStore && SUCCEEDED (hr) )
				{
					if ( param )   // a non-NULL value indicates that a cut/move is desired
					{
						LPDATAOBJECT	srcDO = (LPDATAOBJECT) arg;
						LPDATAOBJECT*	ppDO = reinterpret_cast<LPDATAOBJECT*>(param);
						hr = srcDO->QueryInterface(
								IID_PPV_ARG (IDataObject, ppDO));
					}
					m_pPastedDO = (LPDATAOBJECT) arg;
					pCertStore->Commit ();
				}
				else
					pCertStore->Resync ();
                if ( !bContainsCerts ) 
                {
                    // not necessary for certs - they're 
                    //added to the end
                    m_pConsole->UpdateAllViews (pDataObject, 0, HINT_PASTE_COOKIE);
                }
			}
		}
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::OnNotifyPaste: 0x%x\n", hr);
	return hr;
}

HRESULT CCertMgrComponent::PasteCookie (
		CCertMgrCookie* pPastedCookie,
		CCertMgrCookie* pTargetCookie,
		CCertStore& rCertStore,
		SPECIAL_STORE_TYPE storeType,
		bool bContainsCerts,
		bool bContainsCRLs,
		bool bContainsCTLs,
		HSCOPEITEM hScopeItem,
		bool bRequestConfirmation,
		bool bIsMultipleSelect)
{
	_TRACE (1, L"Entering CCertMgrComponent::PasteCookie\n");
	HRESULT	hr = S_OK;
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

	switch (pPastedCookie->m_objecttype)
	{
	case CERTMGR_CERTIFICATE:
		{
			CCertificate* pCert = reinterpret_cast <CCertificate*>(pPastedCookie);
			ASSERT (pCert);
			if ( pCert )
			{
                DWORD   dwFlags = 0;
                CCertStore* pStore = pCert->GetCertStore ();
                if ( pStore )
                {
                    if ( CERT_SYSTEM_STORE_LOCAL_MACHINE == QueryComponentDataRef ().m_dwLocationPersist )
                        dwFlags = CRYPT_FIND_MACHINE_KEYSET_FLAG;
				    bool bDeletePrivateKey = DeletePrivateKey (rCertStore, *pStore);
				    if ( bRequestConfirmation &&
						    pCert->GetStoreType () == MY_STORE &&
                            bDeletePrivateKey &&
						    ::CryptFindCertificateKeyProvInfo (
							    pCert->GetCertContext (), dwFlags, 0) )
				    {
					    CString	text;
					    CString caption;
					    int		iRetVal = IDNO;

					    if ( bIsMultipleSelect )
						    VERIFY (text.LoadString (IDS_WARNING_MULTI_CERT_COPY_W_PRIVATE_KEY_MULTI));
					    else
						    VERIFY (text.LoadString (IDS_WARNING_CERT_COPY_W_PRIVATE_KEY));
					    VERIFY (caption.LoadString (IDS_CERTIFICATE_COPY));
					    hr = m_pConsole->MessageBox (text, caption,
							    MB_ICONWARNING | MB_YESNO, &iRetVal);
					    ASSERT (SUCCEEDED (hr));
					    if ( iRetVal == IDNO )
						    return E_FAIL;
				    }

				    hr = CopyPastedCert (pCert, rCertStore, storeType, bDeletePrivateKey, 
                            pTargetCookie);
				    if ( SUCCEEDED (hr) && S_FALSE != hr )
				    {
					    hr = pTargetCookie->Commit ();
					    if ( SUCCEEDED (hr) )
					    {
						    if ( !bContainsCerts )
							    hr = QueryComponentDataRef ().CreateContainers (
									    hScopeItem, rCertStore);
					    }
				    }
                }
			}
			else
				hr = E_POINTER;
		}
		break;

	case CERTMGR_CRL:
		{
			CCRL* pCRL = reinterpret_cast <CCRL*>(pPastedCookie);
			ASSERT (pCRL);
			if ( pCRL )
			{
				hr = CopyPastedCRL (pCRL, rCertStore);
				if ( SUCCEEDED (hr) )
				{
					pTargetCookie->Commit ();
					if ( !bContainsCRLs )
						hr = QueryComponentDataRef ().CreateContainers (hScopeItem,
								rCertStore);
				}
			}
			else
				hr = E_POINTER;
		}
		break;

	case CERTMGR_CTL:
		{
			CCTL* pCTL = reinterpret_cast <CCTL*>(pPastedCookie);
			ASSERT (pCTL);
			if ( pCTL )
			{
				hr = CopyPastedCTL (pCTL, rCertStore);
				if ( SUCCEEDED (hr) )
				{
					pTargetCookie->Commit ();
					if ( !bContainsCTLs )
						hr = QueryComponentDataRef ().CreateContainers (hScopeItem,
								rCertStore);
				}
			}
			else
				hr = E_POINTER;
		}
		break;

	case CERTMGR_AUTO_CERT_REQUEST:
		{
			CAutoCertRequest* pAutoCert = reinterpret_cast <CAutoCertRequest*>(pPastedCookie);
			ASSERT (pAutoCert);
			if ( pAutoCert )
			{
				hr = CopyPastedCTL (pAutoCert, rCertStore);
				if ( SUCCEEDED (hr) )
				{
					pTargetCookie->Commit ();
					if ( !bContainsCTLs )
						hr = QueryComponentDataRef ().CreateContainers (hScopeItem,
								rCertStore);
				}
			}
			else
				hr = E_POINTER;
		}
		break;

	default:
		break;
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::PasteCookie: 0x%x\n", hr);
	return hr;
}

HRESULT CCertMgrComponent::OnNotifyQueryPaste(
        LPDATAOBJECT pDataObject, 
        LPARAM arg, 
        LPARAM /*param*/)
{
	_TRACE (1, L"Entering CCertMgrComponent::OnNotifyQueryPaste\n");
	ASSERT (pDataObject && arg);
	if ( !pDataObject || !arg )
		return E_POINTER;

	HRESULT	hr = S_FALSE;
	CCertMgrComponentData& dataRef = QueryComponentDataRef ();

	CCertMgrCookie* pTargetCookie = dataRef.ConvertCookie (pDataObject);
	ASSERT (pTargetCookie);
	if ( pTargetCookie )
	{
		CCertMgrCookie* pPastedCookie =
				dataRef.ConvertCookie ((LPDATAOBJECT) arg);
		if ( pPastedCookie )
		{
			// If this is multi-selection, get the first selected object
			// and substitute it for the pasted cookie.
			if ( ((CCertMgrCookie*) MMC_MULTI_SELECT_COOKIE) == pPastedCookie )
			{
				LPDATAOBJECT	pMSDO = (LPDATAOBJECT) arg;
				if ( pMSDO )
				{
					CCertMgrDataObject* pDO = reinterpret_cast <CCertMgrDataObject*>(pMSDO);
					ASSERT (pDO);
					if ( pDO )
					{
						pDO->Reset();
						if (pDO->Next(1, reinterpret_cast<MMC_COOKIE*>(&pPastedCookie), NULL) == S_FALSE)
						{
							return E_UNEXPECTED;
						}
					}
					else
						return E_UNEXPECTED;
				}
				else
					return E_UNEXPECTED;

			}

			switch (pPastedCookie->m_objecttype)
			{
			case CERTMGR_CERTIFICATE:
				switch (pTargetCookie->m_objecttype)
				{
				case CERTMGR_PHYS_STORE:
				case CERTMGR_LOG_STORE:
                    {
                        CCertStore* pTargetStore = reinterpret_cast <CCertStore*> (pTargetCookie);
                        if ( pTargetStore )
                        {
                            CCertStore* pSourceStore = 
                                    reinterpret_cast <CCertificate*> (pPastedCookie)->GetCertStore ();
                            
                            if ( pSourceStore )
                            {
                                if ( pTargetStore->IsReadOnly () )
                                    hr = S_FALSE;
                                else if ( *pSourceStore == *pTargetStore )
                                    hr = S_FALSE;
                                else
                                    hr = S_OK;
                            }
                            else
                                hr = E_UNEXPECTED;
                        }
                        else
                            hr = E_UNEXPECTED;
                    }
                    break;

				case CERTMGR_CERT_CONTAINER:
                    {
                        CContainerCookie* pContainer = reinterpret_cast <CContainerCookie*> (pTargetCookie);
                        if ( pContainer )
                        {
                            CCertStore* pSourceStore = 
                                    reinterpret_cast <CCertificate*> (pPastedCookie)->GetCertStore ();
                            
                            if ( pSourceStore )
                            {
                                if ( pContainer->GetCertStore ().IsReadOnly () )
                                    hr = S_FALSE;
                                else if ( *pSourceStore == pContainer->GetCertStore () )
                                    hr = S_FALSE;
                                else
                                    hr = S_OK;
                            }
                            else
                                hr = E_UNEXPECTED;
                        }
                        else
                            hr = E_UNEXPECTED;
                    }
                    break;

				case CERTMGR_CERTIFICATE:
                    {
                        CCertificate* pCert = reinterpret_cast <CCertificate*> (pTargetCookie);
                        if ( pCert )
                        {
                            CCertStore* pSourceStore = 
                                    reinterpret_cast <CCertificate*> (pPastedCookie)->GetCertStore ();
                            CCertStore* pTargetStore = pCert->GetCertStore ();
                            
                            if ( pSourceStore && pTargetStore )
                            {
                                if ( pTargetStore->IsReadOnly () )
                                    hr = S_FALSE;
                                else if ( *pSourceStore == *pTargetStore )
                                    hr = S_FALSE;
                                else
                                    hr = S_OK;
                            }
                            else
                                hr = E_UNEXPECTED;
                        }
                        else
                            hr = E_UNEXPECTED;
                    }
					break;

				case CERTMGR_LOG_STORE_GPE:
					{
						CCertStoreGPE* pTargetStore =
								reinterpret_cast <CCertStoreGPE*> (pTargetCookie);
						ASSERT (pTargetStore);
						if ( pTargetStore )
						{
                            CCertStore* pSourceStore = 
                                    reinterpret_cast <CCertificate*> (pPastedCookie)->GetCertStore ();
                            if ( pSourceStore )
                            {
                                if ( *pSourceStore == *pTargetStore )
                                    hr = S_FALSE;
							    else if ( pTargetStore->CanContain (pPastedCookie->m_objecttype) &&
                                        !pTargetStore->IsReadOnly () )
								    hr = S_OK;
                                else
                                    hr = S_OK;
                            }
                            else
                                hr = E_UNEXPECTED;
						}
						else
							hr = E_UNEXPECTED;
					}
					break;

				case CERTMGR_LOG_STORE_RSOP:
					{
						CCertStoreRSOP* pTargetStore =
								reinterpret_cast <CCertStoreRSOP*> (pTargetCookie);
						ASSERT (pTargetStore);
						if ( pTargetStore )
						{
                            CCertStore* pSourceStore = 
                                    reinterpret_cast <CCertificate*> (pPastedCookie)->GetCertStore ();
                            if ( pSourceStore )
                            {
                                if ( *pSourceStore == *pTargetStore )
                                    hr = S_FALSE;
							    else if ( pTargetStore->CanContain (pPastedCookie->m_objecttype) &&
                                        !pTargetStore->IsReadOnly () )
								    hr = S_OK;
                                else
                                    hr = S_OK;
                            }
                            else
                                hr = E_UNEXPECTED;
						}
						else
							hr = E_UNEXPECTED;
					}
					break;

                case CERTMGR_SAFER_COMPUTER_ENTRIES:
                case CERTMGR_SAFER_USER_ENTRIES:
                    hr = S_OK;
                    break;

				default:
					break;
				}
				break;

			case CERTMGR_CRL:
				switch (pTargetCookie->m_objecttype)
				{
				case CERTMGR_PHYS_STORE:
				case CERTMGR_LOG_STORE:
                    {
                        CCertStore* pTargetStore = reinterpret_cast <CCertStore*> (pTargetCookie);
                        if ( pTargetStore )
                        {
                            CCertStore& rSourceStore = 
                                    reinterpret_cast <CCRL*> (pPastedCookie)->GetCertStore ();
                            if ( pTargetStore->IsReadOnly () )
                                hr = S_FALSE;
                            else if ( rSourceStore == *pTargetStore )
                                hr = S_FALSE;
                            else
                                hr = S_OK;
                        }
                        else
                            hr = E_UNEXPECTED;
                    }
                    break;

				case CERTMGR_CRL_CONTAINER:
                    {
                        CContainerCookie* pContainer = reinterpret_cast <CContainerCookie*> (pTargetCookie);
                        if ( pContainer )
                        {
                            CCertStore& rSourceStore = 
                                    reinterpret_cast <CCRL*> (pPastedCookie)->GetCertStore ();
                            
                            if ( pContainer->GetCertStore ().IsReadOnly () )
                                hr = S_FALSE;
                            else if ( rSourceStore == pContainer->GetCertStore () )
                                hr = S_FALSE;
                            else
                                hr = S_OK;
                        }
                        else
                            hr = E_UNEXPECTED;
                    }
                    break;

				case CERTMGR_CRL:
                    {
                        CCRL* pCRL = reinterpret_cast <CCRL*> (pTargetCookie);
                        if ( pCRL )
                        {
                            CCertStore* pSourceStore = 
                                    reinterpret_cast <CCertificate*> (pPastedCookie)->GetCertStore ();
                            CCertStore& rTargetStore = pCRL->GetCertStore ();

                            if ( pSourceStore )
                            {
                                if ( rTargetStore.IsReadOnly () )
                                    hr = S_FALSE;
                                else if ( *pSourceStore == rTargetStore )
                                    hr = S_FALSE;
                                else
                                    hr = S_OK;
                            }
                            else
                                hr = E_UNEXPECTED;
                        }
                        else
                            hr = E_UNEXPECTED;
                    }
					break;

				default:
					break;
				}
				break;

			case CERTMGR_CTL:
				switch (pTargetCookie->m_objecttype)
				{
				case CERTMGR_PHYS_STORE:
				case CERTMGR_LOG_STORE:
                    {
                        CCertStore* pTargetStore = reinterpret_cast <CCertStore*> (pTargetCookie);
                        if ( pTargetStore )
                        {
                            CCertStore& rSourceStore = 
                                    reinterpret_cast <CCTL*> (pPastedCookie)->GetCertStore ();
                            if ( pTargetStore->IsReadOnly () )
                                hr = S_FALSE;
                            else if ( rSourceStore == *pTargetStore )
                                hr = S_FALSE;
                            else
                                hr = S_OK;
                        }
                        else
                            hr = E_UNEXPECTED;
                    }
                    break;

				case CERTMGR_CTL_CONTAINER:
                    {
                        CContainerCookie* pContainer = reinterpret_cast <CContainerCookie*> (pTargetCookie);
                        if ( pContainer )
                        {
                            CCertStore& rSourceStore = 
                                    reinterpret_cast <CCTL*> (pPastedCookie)->GetCertStore ();
                            
                            if ( pContainer->GetCertStore ().IsReadOnly () )
                                hr = S_FALSE;
                            else if ( rSourceStore == pContainer->GetCertStore () )
                                hr = S_FALSE;
                            else
                                hr = S_OK;
                        }
                        else
                            hr = E_UNEXPECTED;
                    }
                    break;

				case CERTMGR_CTL:
                    {
                        CCTL* pCTL = reinterpret_cast <CCTL*> (pTargetCookie);
                        if ( pCTL )
                        {
                            CCertStore* pSourceStore = 
                                    reinterpret_cast <CCertificate*> (pPastedCookie)->GetCertStore ();
                            CCertStore& rTargetStore = pCTL->GetCertStore ();
                            
                            if ( pSourceStore )
                            {
                                if ( rTargetStore.IsReadOnly () )
                                    hr = S_FALSE;
                                else if ( *pSourceStore == rTargetStore )
                                    hr = S_FALSE;
                                else
                                    hr = S_OK;
                            }
                            else
                                hr = E_UNEXPECTED;
                        }
                        else
                            hr = E_UNEXPECTED;
                    }
					break;

				case CERTMGR_LOG_STORE_GPE:
				case CERTMGR_LOG_STORE_RSOP:
					{
						CCertStore* pTargetStore =
								reinterpret_cast <CCertStore*> (pTargetCookie);
						ASSERT (pTargetStore);
						if ( pTargetStore )
						{
                            CCertStore& rSourceStore = 
                                    reinterpret_cast <CCTL*> (pPastedCookie)->GetCertStore ();
                            if ( rSourceStore == *pTargetStore )
                                hr = S_FALSE;
							else if ( pTargetStore->CanContain (pPastedCookie->m_objecttype) &&
                                    !pTargetStore->IsReadOnly () )
								hr = S_OK;
                            else
                                hr = S_OK;
						}
						else
							hr = E_UNEXPECTED;
					}
					break;

				default:
					break;
				}
				break;

			case CERTMGR_AUTO_CERT_REQUEST:
				switch (pTargetCookie->m_objecttype)
				{
				case CERTMGR_LOG_STORE_GPE:
				case CERTMGR_LOG_STORE_RSOP:
					{
						CCertStore* pTargetStore =
								reinterpret_cast <CCertStore*> (pTargetCookie);
						ASSERT (pTargetStore);
						if ( pTargetStore )
						{
							if ( ACRS_STORE == pTargetStore->GetStoreType ()  &&
                                    !pTargetStore->IsReadOnly ())
								hr = S_OK;
						}
						else
							hr = E_UNEXPECTED;
					}
					break;

				default:
					break;
				}
				break;

            case CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS:
            case CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS:
                ASSERT (0);
                break;

			default:
				break;
			}
		}
	}


	_TRACE (-1, L"Leaving CCertMgrComponent::OnNotifyQueryPaste: 0x%x\n", hr);
	return hr;
}

HRESULT CCertMgrComponent::CopyPastedCert(
        CCertificate * pCert, 
        CCertStore& rCertStore, 
        const SPECIAL_STORE_TYPE /*storeType*/, 
        bool bDeletePrivateKey,
        CCertMgrCookie* pTargetCookie)
{
	_TRACE (1, L"Entering CCertMgrComponent::CopyPastedCert\n");
    AFX_MANAGE_STATE (AfxGetStaticModuleState ());
	HRESULT	hr = S_OK;

	ASSERT (pCert);
	if ( pCert )
	{
		PCCERT_CONTEXT	pCertContext = pCert->GetCertContext ();
		ASSERT (pCertContext);
		if ( pCertContext )
		{
			hr = rCertStore.AddCertificateContext (pCertContext,
					m_pConsole, bDeletePrivateKey);
            if ( FAILED (hr) && S_FALSE != hr )
            {
                if ( HRESULT_FROM_WIN32 (CRYPT_E_EXISTS) != hr )
                {
				    CString	text;
				    CString	caption;
				    int		iRetVal = 0;
                    if ( E_INVALIDARG == hr && !rCertStore.GetStoreHandle () )
                    {
                        text.FormatMessage (IDS_CERT_CANNOT_BE_PASTED_CANT_OPEN_STORE, 
                                rCertStore.GetLocalizedName ());
                    }
                    else
                    {
				        text.FormatMessage (IDS_CERT_CANNOT_BE_PASTED, 
                                rCertStore.GetLocalizedName (), 
                                GetSystemMessage (hr));
                    }
			        VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
			        m_pConsole->MessageBox (text, caption,
					        MB_OK, &iRetVal);
                }
            }
            else
            {
				if ( CERTMGR_CERT_CONTAINER == pTargetCookie->m_objecttype )
				{
                    CContainerCookie* pContainerCookie = dynamic_cast <CContainerCookie*> (pTargetCookie);
                    if ( pContainerCookie )
                    {
                        CCertStore* pOriginatingStore = pCert->GetCertStore ();
                        if ( pContainerCookie->GetCertStore ().GetStoreName () == 
                                pOriginatingStore->GetStoreName () )
                        {
                            // Add certificate to result pane
	                        RESULTDATAITEM			rdItem;
	                        CCookie&				rootCookie = 
                                    QueryComponentDataRef ().QueryBaseRootCookie ();

	                        ::ZeroMemory (&rdItem, sizeof (rdItem));
	                        rdItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM | RDI_STATE;
	                        rdItem.nImage = iIconCertificate;
	                        rdItem.nCol = 0;
                            rdItem.nState = LVIS_SELECTED | LVIS_FOCUSED;
	                        rdItem.str = MMC_TEXTCALLBACK;

	                        CCertificate* pNewCert = new CCertificate (
                                    ::CertDuplicateCertificateContext (pCertContext),
                                    &rCertStore);
		                    if ( pNewCert )
                            {
		                        rootCookie.m_listResultCookieBlocks.AddHead (pNewCert);
		                        rdItem.lParam = (LPARAM) pNewCert;
		                        pCert->m_resultDataID = m_pResultData;
		                        hr = m_pResultData->InsertItem (&rdItem);
                                if ( FAILED (hr) )
                                {
                                     _TRACE (0, L"IResultData::InsertItem () failed: 0x%x\n", hr);
                                }
                                else
                                {
                                     hr = DisplayCertificateCountByStore (m_pConsole, 
                                            &rCertStore, false);
                                }
                            }
                            else
			                    hr = E_OUTOFMEMORY;

					        ASSERT (SUCCEEDED (hr));
                        }
                    }
				}
            }
		}
		else
			hr = E_UNEXPECTED;
	}
	else
		hr = E_POINTER;

	_TRACE (-1, L"Leaving CCertMgrComponent::CopyPastedCert: 0x%x\n", hr);
	return hr;
}



HRESULT CCertMgrComponent::CopyPastedCTL(CCTL * pCTL, CCertStore& rCertStore)
{
	_TRACE (1, L"Entering CCertMgrComponent::CopyPastedCTL\n");
	HRESULT	hr = S_OK;

	ASSERT (pCTL);
	if ( pCTL )
	{
		PCCTL_CONTEXT	pCTLContext = pCTL->GetCTLContext ();
		ASSERT (pCTLContext);
		if ( pCTLContext )
		{
			bool	bResult = rCertStore.AddCTLContext (pCTLContext);
			if ( !bResult )
			{
				DWORD	dwErr = GetLastError ();
				if ( CRYPT_E_EXISTS == dwErr )
				{
					CString	text;
					CString	caption;
					int		iRetVal = 0;


					VERIFY (text.LoadString (IDS_DUPLICATE_CTL));
					VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
					hr = m_pConsole->MessageBox (text, caption,
							MB_OK, &iRetVal);
					ASSERT (SUCCEEDED (hr));
					hr = E_FAIL;
				}
				else
				{
					ASSERT (0);
					hr = HRESULT_FROM_WIN32 (dwErr);
				}
			}
		}
		else
			hr = E_UNEXPECTED;
	}
	else
		hr = E_POINTER;

	_TRACE (-1, L"Leaving CCertMgrComponent::CopyPastedCTL: 0x%x\n", hr);
	return hr;
}


HRESULT CCertMgrComponent::CopyPastedCRL(CCRL * pCRL, CCertStore& rCertStore)
{
	_TRACE (1, L"Entering CCertMgrComponent::CopyPastedCRL\n");
    AFX_MANAGE_STATE (AfxGetStaticModuleState ());
	HRESULT	hr = S_OK;

	ASSERT (pCRL);
	if ( pCRL )
	{
		PCCRL_CONTEXT	pCRLContext = pCRL->GetCRLContext ();
		ASSERT (pCRLContext);
		if ( pCRLContext )
		{
			bool	bResult = rCertStore.AddCRLContext (pCRLContext);
			if ( !bResult )
			{
				DWORD	dwErr = GetLastError ();
				if ( CRYPT_E_EXISTS == dwErr )
				{
					CString	text;
					CString	caption;
					int		iRetVal = 0;


					VERIFY (text.LoadString (IDS_DUPLICATE_CRL));
					VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
					hr = m_pConsole->MessageBox (text, caption,
							MB_OK, &iRetVal);
					ASSERT (SUCCEEDED (hr));
					hr = E_FAIL;
				}
				else
				{
					ASSERT (0);
					hr = HRESULT_FROM_WIN32 (dwErr);
				}
			}
		}
		else
			hr = E_UNEXPECTED;
	}
	else
		hr = E_POINTER;

	_TRACE (-1, L"Leaving CCertMgrComponent::CopyPastedCRL: 0x%x\n", hr);
	return hr;
}


STDMETHODIMP CCertMgrComponent::GetResultViewType(MMC_COOKIE cookie,
		BSTR* ppViewType,
		long* pViewOptions) 
{
	_TRACE (1, L"Entering CCertMgrComponent::GetResultViewType\n");
    HRESULT         hr = S_FALSE;
	CCertMgrCookie* pScopeCookie = reinterpret_cast <CCertMgrCookie*> (cookie);
	if ( pScopeCookie )
	{
		switch (pScopeCookie->m_objecttype)
		{
		case CERTMGR_CERT_CONTAINER:
		case CERTMGR_CTL_CONTAINER:
		case CERTMGR_CRL_CONTAINER:
		case CERTMGR_LOG_STORE_GPE:
		case CERTMGR_LOG_STORE_RSOP:
		case CERTMGR_USAGE:
        case CERTMGR_SAFER_COMPUTER_ENTRIES:
        case CERTMGR_SAFER_USER_ENTRIES:
			*pViewOptions |= MMC_VIEW_OPTIONS_MULTISELECT;
            *ppViewType = NULL;
			break;

        case CERTMGR_SAFER_COMPUTER_ROOT:
        case CERTMGR_SAFER_USER_ROOT:
            {
                CSaferRootCookie* pSaferRootCookie = dynamic_cast <CSaferRootCookie*> (pScopeCookie);
                if ( pSaferRootCookie )
                {
                    if ( pSaferRootCookie->m_bCreateSaferNodes )
                    {
       			        *pViewOptions |= MMC_VIEW_OPTIONS_MULTISELECT;
                        *ppViewType = NULL;
                    }
                    else
                    {
                        *pViewOptions = MMC_VIEW_OPTIONS_NOLISTVIEWS;

                        LPOLESTR psz = NULL;
                        StringFromCLSID(CLSID_MessageView, &psz);

                        USES_CONVERSION;

                        if (psz != NULL)
                        {
                            *ppViewType = psz;
                            hr = S_OK;
                        }
                    }
                }
            }
            break;

		default:
            *ppViewType = NULL;
			break;
		}
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::GetResultViewType: 0x%x\n", hr);
     return hr;
}


STDMETHODIMP CCertMgrComponent::Initialize(LPCONSOLE lpConsole)
{
	_TRACE (1, L"Entering CCertMgrComponent::Initialize\n");
	HRESULT	 hr = CComponent::Initialize (lpConsole);
	if ( SUCCEEDED (hr) )
	{
		ASSERT (m_pHeader);
		QueryComponentDataRef ().m_pHeader = m_pHeader;

        if ( lpConsole )
        {
           if ( QueryComponentDataRef ().m_pComponentConsole )
                 SAFE_RELEASE (QueryComponentDataRef ().m_pComponentConsole);
           QueryComponentDataRef ().m_pComponentConsole = m_pConsole;
           QueryComponentDataRef ().m_pComponentConsole->AddRef ();
        }
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::Initialize: 0x%x\n", hr);
	return hr;
}


HRESULT CCertMgrComponent::LoadColumnsFromArrays (INT objecttype )
{
	_TRACE (1, L"Entering CCertMgrComponent::LoadColumnsFromArrays\n");
     ASSERT (m_pHeader);

	CString str;
	for ( INT i = 0; 0 != m_Columns[objecttype][i]; i++)
	{
		VERIFY(str.LoadString (m_Columns[objecttype][i]));
		m_pHeader->InsertColumn(i, const_cast<LPWSTR>((LPCWSTR)str), LVCFMT_LEFT,
			m_ColumnWidths[objecttype][i]);
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::LoadColumnsFromArrays: S_OK\n");
	return S_OK;
}

HRESULT CCertMgrComponent::SaveWidths(CCertMgrCookie * pCookie)
{
	_TRACE (1, L"Entering CCertMgrComponent::SaveWidths\n");
	HRESULT	hr = S_OK;

	m_fDirty = TRUE;

	ASSERT (pCookie);
	if ( pCookie )
	{
		switch (m_pViewedCookie->m_objecttype)
		{
		case CERTMGR_SNAPIN:
		case CERTMGR_USAGE:
		case CERTMGR_PHYS_STORE:
		case CERTMGR_LOG_STORE:
		case CERTMGR_CRL_CONTAINER:
		case CERTMGR_CTL_CONTAINER:
		case CERTMGR_CERT_CONTAINER:
		case CERTMGR_LOG_STORE_GPE:
		case CERTMGR_LOG_STORE_RSOP:
		case CERTMGR_CERT_POLICIES_USER:
		case CERTMGR_CERT_POLICIES_COMPUTER:
        case CERTMGR_SAFER_COMPUTER_ROOT:
        case CERTMGR_SAFER_USER_ROOT:
        case CERTMGR_SAFER_COMPUTER_LEVELS:
        case CERTMGR_SAFER_USER_LEVELS:
        case CERTMGR_SAFER_COMPUTER_ENTRIES:
        case CERTMGR_SAFER_USER_ENTRIES:
			{
				const UINT* pColumns = m_Columns[m_pViewedCookie->m_objecttype];
				ASSERT(pColumns);
				int    nWidth = 0;

				for (UINT iIndex = 0; iIndex < pColumns[iIndex]; iIndex++)
				{
					hr = m_pHeader->GetColumnWidth ((int) iIndex, &nWidth);
					if ( SUCCEEDED (hr) )
					{
						m_ColumnWidths[m_pViewedCookie->m_objecttype][iIndex] =
								(UINT) nWidth;
					}
					else
						break;
				}
			}
			break;

		case CERTMGR_CERTIFICATE:
		case CERTMGR_CRL:
		case CERTMGR_CTL:
		case CERTMGR_AUTO_CERT_REQUEST:
        case CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS:
        case CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS:
        case CERTMGR_SAFER_COMPUTER_LEVEL:
        case CERTMGR_SAFER_USER_LEVEL:
        case CERTMGR_SAFER_COMPUTER_ENTRY:
        case CERTMGR_SAFER_USER_ENTRY:
		default:
			ASSERT (0);
			break;
		}
	}
	else
		hr = E_POINTER;

	_TRACE (-1, L"Leaving CCertMgrComponent::SaveWidths: 0x%x\n", hr);
	return hr;
}


///////////////////////////////////////////////////////////////////////////////
#define _dwMagicword	10000  // Internal version number
STDMETHODIMP CCertMgrComponent::Load(IStream __RPC_FAR *pIStream)
{
	_TRACE (1, L"Entering CCertMgrComponent::Load\n");
	HRESULT hr = S_OK;

#ifndef DONT_PERSIST
	ASSERT (pIStream);
	XSafeInterfacePtr<IStream> pIStreamSafePtr( pIStream );

	// Read the magic word from the stream
	DWORD dwMagicword = 0;
	hr = pIStream->Read (&dwMagicword, sizeof(dwMagicword), NULL);
	if ( FAILED(hr) )
	{
		ASSERT( FALSE );
		return hr;
	}
	if (dwMagicword != _dwMagicword)
	{
		// We have a version mismatch
		_TRACE (0, L"INFO: CCertMgrComponentData::Load() - Wrong Magicword.  You need to re-save your .msc file.\n");
		return E_FAIL;
	}

	int	numCols = 0;

	for (int iIndex = 0; iIndex < CERTMGR_NUMTYPES && SUCCEEDED (hr); iIndex++)
	{
		switch (iIndex)
		{
		case CERTMGR_USAGE:
		case CERTMGR_CERT_CONTAINER:
			numCols = CERT_NUM_COLS;
			break;

		case CERTMGR_CRL_CONTAINER:
			numCols = CRL_NUM_COLS;
			break;

		case CERTMGR_CTL_CONTAINER:
			numCols = CTL_NUM_COLS;
			break;

		case CERTMGR_SNAPIN:
		case CERTMGR_PHYS_STORE:
		case CERTMGR_LOG_STORE:
		case CERTMGR_LOG_STORE_GPE:
		case CERTMGR_LOG_STORE_RSOP:
        case CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS:
        case CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS:
        case CERTMGR_SAFER_COMPUTER_ROOT:
        case CERTMGR_SAFER_USER_ROOT:
        case CERTMGR_SAFER_COMPUTER_TRUSTED_PUBLISHERS:
        case CERTMGR_SAFER_USER_TRUSTED_PUBLISHERS:
        case CERTMGR_SAFER_COMPUTER_DEFINED_FILE_TYPES:
        case CERTMGR_SAFER_USER_DEFINED_FILE_TYPES:
        case CERTMGR_SAFER_COMPUTER_ENFORCEMENT:
        case CERTMGR_SAFER_USER_ENFORCEMENT:
			numCols = 1;
			break;

        case CERTMGR_SAFER_COMPUTER_LEVELS:
        case CERTMGR_SAFER_USER_LEVELS:
            numCols = SAFER_LEVELS_NUM_COLS;
            break;

        case CERTMGR_SAFER_COMPUTER_ENTRIES:
        case CERTMGR_SAFER_USER_ENTRIES:
            numCols = SAFER_ENTRIES_NUM_COLS;
            break;

		case CERTMGR_CERTIFICATE:
		case CERTMGR_CRL:
		case CERTMGR_CTL:
		case CERTMGR_AUTO_CERT_REQUEST:
		case CERTMGR_CERT_POLICIES_USER:
		case CERTMGR_CERT_POLICIES_COMPUTER:
        case CERTMGR_SAFER_COMPUTER_LEVEL:
        case CERTMGR_SAFER_USER_LEVEL:
        case CERTMGR_SAFER_COMPUTER_ENTRY:
        case CERTMGR_SAFER_USER_ENTRY:
			continue;

		default:
			ASSERT (0);
			break;
		}

		for (int colNum = 0; colNum < numCols; colNum++)
		{
			hr = pIStream->Read (&(m_ColumnWidths[iIndex][colNum]),
					sizeof (UINT), NULL);
			ASSERT (SUCCEEDED (hr));
			if ( FAILED(hr) )
			{
				ASSERT (FALSE);
				break;
			}
		}
	}
#endif
	_TRACE (-1, L"Leaving CCertMgrComponent::Load: 0x%x\n", hr);
	return S_OK;
}


///////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CCertMgrComponent::Save(
        IStream __RPC_FAR *pIStream, 
        BOOL /*fSameAsLoad*/)
{
	_TRACE (1, L"Entering CCertMgrComponent::Save\n");
	HRESULT hr = S_OK;


#ifndef DONT_PERSIST
	ASSERT (pIStream);
	XSafeInterfacePtr<IStream> pIStreamSafePtr (pIStream);

	// Store the magic word to the stream
	DWORD dwMagicword = _dwMagicword;
	hr = pIStream->Write (&dwMagicword, sizeof(dwMagicword), NULL);
	ASSERT (SUCCEEDED (hr));
	if ( FAILED (hr) )
		return hr;


	int	numCols = 0;

	for (int iIndex = 0; iIndex < CERTMGR_NUMTYPES && SUCCEEDED (hr); iIndex++)
	{
		switch (iIndex)
		{
		case CERTMGR_USAGE:
		case CERTMGR_CERT_CONTAINER:
			numCols = CERT_NUM_COLS;
			break;

		case CERTMGR_CRL_CONTAINER:
			numCols = CRL_NUM_COLS;
			break;

		case CERTMGR_CTL_CONTAINER:
			numCols = CTL_NUM_COLS;
			break;

		case CERTMGR_SNAPIN:
		case CERTMGR_PHYS_STORE:
		case CERTMGR_LOG_STORE:
		case CERTMGR_LOG_STORE_GPE:
		case CERTMGR_LOG_STORE_RSOP:
		case CERTMGR_CERT_POLICIES_USER:
		case CERTMGR_CERT_POLICIES_COMPUTER:
        case CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS:
        case CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS:
        case CERTMGR_SAFER_COMPUTER_ROOT:
        case CERTMGR_SAFER_USER_ROOT:
        case CERTMGR_SAFER_COMPUTER_TRUSTED_PUBLISHERS:
        case CERTMGR_SAFER_USER_TRUSTED_PUBLISHERS:
        case CERTMGR_SAFER_COMPUTER_DEFINED_FILE_TYPES:
        case CERTMGR_SAFER_USER_DEFINED_FILE_TYPES:
        case CERTMGR_SAFER_COMPUTER_ENFORCEMENT:
        case CERTMGR_SAFER_USER_ENFORCEMENT:
			numCols = 1;
			break;

        case CERTMGR_SAFER_COMPUTER_ENTRIES:
        case CERTMGR_SAFER_USER_ENTRIES:
            numCols = SAFER_ENTRIES_NUM_COLS;
            break;

        case CERTMGR_SAFER_COMPUTER_LEVELS:
        case CERTMGR_SAFER_USER_LEVELS:
            numCols = SAFER_LEVELS_NUM_COLS;
            break;

		case CERTMGR_CERTIFICATE:
		case CERTMGR_CRL:
		case CERTMGR_CTL:
		case CERTMGR_AUTO_CERT_REQUEST:
        case CERTMGR_SAFER_COMPUTER_LEVEL:
        case CERTMGR_SAFER_USER_LEVEL:
        case CERTMGR_SAFER_COMPUTER_ENTRY:
        case CERTMGR_SAFER_USER_ENTRY:
			continue;

		default:
			ASSERT (0);
			break;
		}

		for (int colNum = 0; colNum < numCols; colNum++)
		{
			hr = pIStream->Write (&(m_ColumnWidths[iIndex][colNum]),
					sizeof (UINT), NULL);
			ASSERT (SUCCEEDED (hr));
			if ( FAILED(hr) )
			{
				ASSERT (FALSE);
				break;
			}
		}
	}
#endif

	_TRACE (-1, L"Leaving CCertMgrComponent::Save: 0x%x\n", hr);
	return S_OK;
}

HRESULT CCertMgrComponent::OnNotifyCutOrMove(LPARAM arg)
{
	_TRACE (1, L"Entering CCertMgrComponent::OnNotifyCutOrMove\n");
	if ( !arg )
		return E_POINTER;

	LPDATAOBJECT pDataObject = reinterpret_cast <IDataObject*> (arg);
	ASSERT (pDataObject);
	if ( !pDataObject )
		return E_UNEXPECTED;


	HRESULT			hr = S_OK;

	CCertMgrCookie* pCookie =
			QueryComponentDataRef ().ConvertCookie (pDataObject);
	if ( pCookie )
	{
		if ( ((CCertMgrCookie*) MMC_MULTI_SELECT_COOKIE) == pCookie )
		{
			CCertMgrDataObject* pDO = reinterpret_cast <CCertMgrDataObject*>(pDataObject);
			ASSERT (pDO);
			if ( pDO )
			{
//                CCertStore& rCertStore = pCookie->GetCertStore ();
				pDO->Reset();
				while (pDO->Next(1, reinterpret_cast<MMC_COOKIE*>(&pCookie), NULL) != S_FALSE)
				{
					hr = DeleteCookie (pCookie, pDataObject, false, true, false);
				}

//                hr = rCertStore.Commit ();
//			    if ( SUCCEEDED (hr) )
//				    rCertStore.Resync ();
			}
			else
				hr = E_FAIL;
		}
		else
		{
			hr = DeleteCookie (pCookie, pDataObject, false, false, true);
		}
		if ( SUCCEEDED (hr) )
			RefreshResultPane ();
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::OnNotifyCutOrMove: 0x%x\n", hr);
	return hr;
}



CCertMgrCookie* CCertMgrComponent::ConvertCookie(LPDATAOBJECT pDataObject)
{
	CCertMgrCookie* pCookie = 0;

	pCookie = QueryComponentDataRef ().ConvertCookie (pDataObject);
	return pCookie;
}

HRESULT CCertMgrComponent::OnOpen (LPDATAOBJECT pDataObject)
{
	_TRACE (1, L"Entering CCertMgrComponent::OnOpen\n");
	HRESULT	hr = S_OK;
	ASSERT (pDataObject);
	CCertMgrCookie* pParentCookie = ConvertCookie (pDataObject);
	if ( pParentCookie )
	{
		switch (pParentCookie->m_objecttype)
		{
		case CERTMGR_CERTIFICATE:
			{
				CCertificate*	pCert = reinterpret_cast <CCertificate*> (pParentCookie);
				ASSERT (pCert);
				if ( pCert )
				{
					hr = LaunchCommonCertDialog (pCert);
				}
				else
					hr = E_UNEXPECTED;
			}
			break;

		case CERTMGR_CTL:
			{
				CCTL*	pCTL = reinterpret_cast <CCTL*> (pParentCookie);
				ASSERT (pCTL);
				if ( pCTL )
				{
					hr = LaunchCommonCTLDialog (pCTL);
					if ( SUCCEEDED (hr) )
						hr = RefreshResultItem (pParentCookie);
				}
				else
					hr = E_UNEXPECTED;
			}
			break;

		case CERTMGR_CRL:
			{
				CCRL*	pCRL = reinterpret_cast <CCRL*> (pParentCookie);
				ASSERT (pCRL);
				if ( pCRL )
				{
					hr = LaunchCommonCRLDialog (pCRL);
					if ( SUCCEEDED (hr) )
						hr = RefreshResultItem (pParentCookie);
				}
				else
					hr = E_UNEXPECTED;
			}
			break;

			break;

		default:
			ASSERT (0);
			break;
		}
	}
	else
		hr = E_UNEXPECTED;

	_TRACE (-1, L"Leaving CCertMgrComponent::OnOpen: 0x%x\n", hr);
	return hr;
}


HRESULT CCertMgrComponent::LaunchCommonCertDialog (CCertificate* pCert)
{
	_TRACE (1, L"Entering CCertMgrComponent::LaunchCommonCertDialog\n");
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	ASSERT (pCert);
	if ( !pCert )
		return E_POINTER;

     CWaitCursor                           waitCursor;
	HWND							hwndParent = 0;
	HRESULT							hr = m_pConsole->GetMainWindow (&hwndParent);
	ASSERT (SUCCEEDED (hr));
	CCertMgrComponentData&	dataRef = QueryComponentDataRef ();
	CTypedPtrList<CPtrList, CCertStore*>	storeList;

	//  Add the Root store first on a remote machine.
	if ( !IsLocalComputername (dataRef.GetManagedComputer ()) )
	{
		storeList.AddTail (new CCertStore (CERTMGR_LOG_STORE,
				CERT_STORE_PROV_SYSTEM,
				CERT_SYSTEM_STORE_LOCAL_MACHINE,
				(LPCWSTR) dataRef.GetManagedComputer (),
				ROOT_SYSTEM_STORE_NAME,
				ROOT_SYSTEM_STORE_NAME,
				_T (""), ROOT_STORE,
				CERT_SYSTEM_STORE_LOCAL_MACHINE,
				m_pConsole));
	}

	hr = dataRef.EnumerateLogicalStores (&storeList);
	if ( SUCCEEDED (hr) )
	{
          POSITION pos = 0;
          POSITION prevPos = 0;

          // Validate store handles
		for (pos = storeList.GetHeadPosition ();
				pos;)
		{
               prevPos = pos;
			CCertStore* pStore = storeList.GetNext (pos);
			ASSERT (pStore);
			if ( pStore )
			{
                // Do not open the userDS store
                if ( USERDS_STORE == pStore->GetStoreType () )
                {
                    storeList.RemoveAt (prevPos);
                    pStore->Release ();
                    pStore = 0;
                }
                else
                {
				    if ( !pStore->GetStoreHandle () )
                    {
                        int      iRetVal = 0;
                        CString	caption;
                        CString	text;

                        text.FormatMessage (IDS_CANT_OPEN_STORE_AND_FAIL, pStore->GetLocalizedName ());
                        VERIFY (caption.LoadString (IDS_CERTIFICATE_MANAGER));
                        hr = E_FAIL;
                        VERIFY (SUCCEEDED (m_pConsole->MessageBox (text, caption, 
                              MB_ICONWARNING | MB_OK, &iRetVal)));
                        break;
                    }
                }
			}
		}

          // Proceed only if all handles are valid 
          if ( SUCCEEDED (hr) )
          {
		     CRYPTUI_VIEWCERTIFICATE_STRUCT	vcs;
		     ::ZeroMemory (&vcs, sizeof (vcs));
		     vcs.dwSize = sizeof (vcs);
		     vcs.hwndParent = hwndParent;

		     //  Set these flags only on a remote machine.
		     if ( !IsLocalComputername (dataRef.GetManagedComputer ()) )
			     vcs.dwFlags = CRYPTUI_DONT_OPEN_STORES | CRYPTUI_WARN_UNTRUSTED_ROOT;
		     else
			     vcs.dwFlags = 0;

             // All dialogs should be read-only under RSOP
             if ( dataRef.m_bIsRSOP || pCert->IsReadOnly () )
                 vcs.dwFlags |= CRYPTUI_DISABLE_EDITPROPERTIES;

		     vcs.pCertContext = pCert->GetNewCertContext ();
		     vcs.cStores = (DWORD)storeList.GetCount ();
		     vcs.rghStores = new HCERTSTORE[vcs.cStores];
		     if ( vcs.rghStores )
		     {
			     CCertStore*		pStore = 0;
			     DWORD			index = 0;

			     for (pos = storeList.GetHeadPosition ();
					     pos && index < vcs.cStores;
					     index++)
			     {
				     pStore = storeList.GetNext (pos);
				     ASSERT (pStore);
				     if ( pStore )
				     {
					     vcs.rghStores[index] = pStore->GetStoreHandle ();
				     }
			     }

			     BOOL fPropertiesChanged = FALSE;
          	     _TRACE (0, L"Calling CryptUIDlgViewCertificate()\n");
                 CThemeContextActivator activator;
			     BOOL bResult = ::CryptUIDlgViewCertificate (&vcs, &fPropertiesChanged);
			     if ( bResult )
			     {
				     if ( fPropertiesChanged )
				     {
                         pStore = pCert->GetCertStore ();
                         if ( pStore )
                         {
					         pStore->SetDirty ();
						     pStore->Commit ();
						     pStore->Close ();
					         if ( IDM_USAGE_VIEW == dataRef.m_activeViewPersist )
					         {
						         // In case purposes were changed and the cert needs to be removed
						         RefreshResultPane ();
					         }
					         else
						         RefreshResultItem (pCert);
                         }
				     }
			     }

			     delete vcs.rghStores;
		     }
		     else
			     hr = E_OUTOFMEMORY;
        }

		while (!storeList.IsEmpty () )
		{
			CCertStore* pStore = storeList.RemoveHead ();
			if ( pStore )
			{
				pStore->Close ();
				pStore->Release ();
			}
		}
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::LaunchCommonCertDialog: 0x%x\n", hr);
	return hr;
}

HRESULT CCertMgrComponent::RefreshResultItem (CCertMgrCookie* pCookie)
{
	_TRACE (1, L"Entering CCertMgrComponent::RefreshResultItem\n");
	HRESULT	hr = S_OK;
	if ( pCookie )
	{
		HRESULTITEM	itemID = 0;

		if ( m_pResultData )
		{
			pCookie->Refresh ();
			hr = m_pResultData->FindItemByLParam ( (LPARAM) pCookie, &itemID);
			if ( SUCCEEDED (hr) )
			{
				hr = m_pResultData->UpdateItem (itemID);
				if ( FAILED (hr) )
				{
					_TRACE (0, L"IResultData::UpdateItem () failed: 0x%x\n", hr);          
				}
			}
			else
			{
				_TRACE (0, L"IResultData::FindItemByLParam () failed: 0x%x\n", hr);          
			}
		}
		else
		{
			_TRACE (0, L"Unexpected error: m_pResultData was NULL\n");
			hr = E_FAIL;
		}
	}
	else
	{
		_TRACE (0, L"Unexpected error: pCookie parameter was NULL\n");
		hr = E_POINTER;
	}

	_TRACE (-1, L"Leaving CCertMgrComponent::RefreshResultItem: 0x%x\n", hr);
	return hr;
}


HRESULT CCertMgrComponent::LaunchCommonCTLDialog (CCTL* pCTL)
{
	_TRACE (1, L"Entering CCertMgrComponent::LaunchCommonCTLDialog\n");
     HRESULT hr = S_OK;
	if ( pCTL )
     {
	     CRYPTUI_VIEWCTL_STRUCT	vcs;
	     HWND					hwndParent = 0;
	     
          hr = m_pConsole->GetMainWindow (&hwndParent);
	     if ( FAILED (hr) )
          {
               _TRACE (0, L"IConsole::GetMainWindow () failed: 0x%x\n", hr);
          }
	     ::ZeroMemory (&vcs, sizeof (vcs));
	     vcs.dwSize = sizeof (vcs);
	     vcs.hwndParent = hwndParent;
	     vcs.dwFlags = 0;

         // All dialogs should be read-only under RSOP
         if ( QueryComponentDataRef ().m_bIsRSOP )
             vcs.dwFlags |= CRYPTUI_DISABLE_EDITPROPERTIES;

	     vcs.pCTLContext = pCTL->GetCTLContext ();

         CThemeContextActivator activator;
	     VERIFY (::CryptUIDlgViewCTL (&vcs));
     }
     else
          hr = E_POINTER;

	_TRACE (-1, L"Leaving CCertMgrComponent::LaunchCommonCTLDialog: 0x%x\n", hr);
	return hr;
}


HRESULT CCertMgrComponent::LaunchCommonCRLDialog (CCRL* pCRL)
{
    _TRACE (1, L"Entering CCertMgrComponent::LaunchCommonCRLDialog\n");
    ASSERT (pCRL);
    CRYPTUI_VIEWCRL_STRUCT	vcs;
    HWND					hwndParent;
    HRESULT					hr = m_pConsole->GetMainWindow (&hwndParent);
    ASSERT (SUCCEEDED (hr));

    ::ZeroMemory (&vcs, sizeof (vcs));
    vcs.dwSize = sizeof (vcs);
    vcs.hwndParent = hwndParent;
    vcs.dwFlags = 0;

    // All dialogs should be read-only under RSOP
    if ( QueryComponentDataRef ().m_bIsRSOP )
        vcs.dwFlags |= CRYPTUI_DISABLE_EDITPROPERTIES;

    vcs.pCRLContext = pCRL->GetCRLContext ();

    CThemeContextActivator activator;
    VERIFY (::CryptUIDlgViewCRL (&vcs));

    _TRACE (-1, L"Leaving CCertMgrComponent::LaunchCommonCRLDialog: 0x%x\n", hr);
    return hr;
}




void CCertMgrComponent::CloseAndReleaseUsageStores()
{
	_TRACE (1, L"Entering CCertMgrComponent::CloseAndReleaseUsageStores\n");
	CCertStore*	pCertStore = 0;
	while (!m_usageStoreList.IsEmpty () )
	{
		pCertStore = m_usageStoreList.RemoveHead ();
		ASSERT (pCertStore);
		if ( pCertStore )
			pCertStore->Release ();
	}
	_TRACE (-1, L"Leaving CCertMgrComponent::CloseAndReleaseUsageStores\n");
}

bool CCertMgrComponent::DeletePrivateKey(CCertStore& rCertStoreDest, CCertStore& rCertStoreSrc)
{
	_TRACE (1, L"Entering CCertMgrComponent::DeletePrivateKey\n");
	bool bDeletePrivateKey = false;


	// Do not copy the private key if the stores are on different machines or
	// if the destination store is in the GPO.
	if ( rCertStoreDest.m_strMachineName  != rCertStoreSrc.m_strMachineName )
		bDeletePrivateKey = true;
	else if ( !rCertStoreDest.GetLocation () ) // Store is GPO store
		bDeletePrivateKey = true;
	

	_TRACE (-1, L"Leaving CCertMgrComponent::DeletePrivateKey\n");
	return bDeletePrivateKey;
}


/////////////////////////////////////////////////////////////////////
// Virtual function called by CComponent::IComponent::Notify(MMCN_PROPERTY_CHANGE)
// OnPropertyChange() is generated by MMCPropertyChangeNotify( param )
HRESULT CCertMgrComponent::OnPropertyChange (LPARAM param)
{
	_TRACE (1, L"Entering CCertMgrComponent::OnPropertyChange\n");
	HRESULT	hr = S_OK;

	hr = QueryComponentDataRef ().OnPropertyChange (param);
	_TRACE (-1, L"Leaving CCertMgrComponent::OnPropertyChange: 0x%x\n", hr);
	return hr;
}


HRESULT CCertMgrComponent::DisplayCertificateCountByUsage(const CString & usageName, int nCertCnt) const
{
	_TRACE (1, L"Entering CCertMgrComponent::DisplayCertificateCountByUsage\n");
     AFX_MANAGE_STATE (AfxGetStaticModuleState ( ));
	ASSERT (!usageName.IsEmpty ());
	ASSERT (nCertCnt >= 0);
     IConsole2*	pConsole2 = 0;
     HRESULT		hr = m_pConsole->QueryInterface (
			IID_PPV_ARG (IConsole2, &pConsole2));
     if (SUCCEEDED (hr))
     {
		CString	statusText;


          switch (nCertCnt)
          {
               case 0:
				statusText.FormatMessage (IDS_STATUS_NO_CERTS_USAGE, usageName);
                     break;

               case 1:
				statusText.FormatMessage (IDS_STATUS_ONE_CERT_USAGE, usageName);
                     break;

               default:
				WCHAR	wszCertCount[16];

				AfxFormatString2 (statusText, IDS_STATUS_X_CERTS_USAGE,
						_itow (nCertCnt, wszCertCount, 10), (LPCWSTR) usageName);
                     break;
          }

          hr = pConsole2->SetStatusText ((LPWSTR)(LPCWSTR) statusText);	

          pConsole2->Release ();
     }

	_TRACE (-1, L"Leaving CCertMgrComponent::DisplayCertificateCountByUsage: 0x%x\n", hr);
	return hr;
}

HRESULT CCertMgrComponent::OnNotifySnapinHelp (LPDATAOBJECT pDataObject)
{
    HRESULT hr = S_OK;

    CComQIPtr<IDisplayHelp,&IID_IDisplayHelp>	spDisplayHelp = m_pConsole;
    if ( !!spDisplayHelp )
    {
        CString strHelpTopic;

        UINT nLen = ::GetSystemWindowsDirectory (strHelpTopic.GetBufferSetLength(2 * MAX_PATH), 2 * MAX_PATH);
        strHelpTopic.ReleaseBuffer();
        if ( nLen )
        {
            /*
            * Help on the stores / purposes should start HTML help with Certficate Manager / Concepts / Understanding Certificate 	Manager / Certificate stores.
            topic is CMconcepts.chm::/sag_CMunCertStor.htm
            * Help on the Certificates / CTL / CRL nodes on the scope pane should open Certificate Manager / Concepts / 	Understanding Certificate Manager.
            topic is CMconcepts.chm::/sag_CMunderstandWks.htm
            * Help on certificates / CTL / CRL objects on the result pane should open Certificate Manager / Concepts / Using Certificate 	Manager.
            topic is CMconcepts.chm::/sag_CMusingWks.htm
            * Help on the Certificate Manager node should launch help with Certificate Manager.
            topic is CMconcepts.chm::/sag_CMtopNode.htm
            */
            CString helpFile;
            CString helpTopic;
            CCertMgrComponentData&	compData = QueryComponentDataRef ();
            CCertMgrCookie* pCookie = compData.ConvertCookie (pDataObject);
            if ( pCookie )
            {
                switch (pCookie->m_objecttype)
                {
                    case CERTMGR_LOG_STORE_GPE:
                    case CERTMGR_LOG_STORE_RSOP:
                    case CERTMGR_CERT_POLICIES_USER:
                    case CERTMGR_CERT_POLICIES_COMPUTER:
                    case CERTMGR_AUTO_CERT_REQUEST:
                    case CERTMGR_PKP_AUTOENROLLMENT_COMPUTER_SETTINGS:
                    case CERTMGR_PKP_AUTOENROLLMENT_USER_SETTINGS:
                        helpFile = PKP_LINKED_HELP_FILE;
                        helpTopic = PKP_HELP_TOPIC;
                        break;

                    case CERTMGR_LOG_STORE:
                    case CERTMGR_PHYS_STORE:
                    case CERTMGR_USAGE:
                        helpFile = CM_LINKED_HELP_FILE;
                        helpTopic = CM_HELP_TOPIC;
                        break;

                    case CERTMGR_CRL_CONTAINER:
                    case CERTMGR_CTL_CONTAINER:
                    case CERTMGR_CERT_CONTAINER:
                        helpFile = CM_LINKED_HELP_FILE;
                        helpTopic = CM_HELP_TOPIC;
                        break;

                    case CERTMGR_CERTIFICATE:
                    {
                        CCertificate* pCert = reinterpret_cast <CCertificate*> (pCookie);
                        if ( pCert )
                        {
                            CCertStore* pStore = pCert->GetCertStore ();
                            if ( pStore )
                            {
                                if ( EFS_STORE == pStore->GetStoreType () )
                                {
                                    helpFile = PKP_LINKED_HELP_FILE;
                                    helpTopic = PKP_HELP_TOPIC;
                                }
                                else
                                {
                                    helpFile = CM_LINKED_HELP_FILE;
                                    helpTopic = CM_HELP_TOPIC;
                                }
                            }
                        }
                    }
                    break;

                    case CERTMGR_CRL:
                    {
                        CCRL* pCRL = reinterpret_cast <CCRL*> (pCookie);
                        if ( pCRL )
                        {
                            if ( EFS_STORE == pCRL->GetCertStore ().GetStoreType () )
                            {
                                helpFile = PKP_LINKED_HELP_FILE;
                                helpTopic = PKP_HELP_TOPIC;
                            }
                            else
                            {
                                helpFile = CM_LINKED_HELP_FILE;
                                helpTopic = CM_HELP_TOPIC;
                            }
                        }
                    }
                    break;

                    case CERTMGR_CTL:
                    {
                        CCTL* pCTL = reinterpret_cast <CCTL*> (pCookie);
                        if ( pCTL )
                        {
                            if ( EFS_STORE == pCTL->GetCertStore ().GetStoreType () )
                            {
                                helpFile = PKP_LINKED_HELP_FILE;
                                helpTopic = PKP_HELP_TOPIC;
                            }
                            else
                            {
                                helpFile = CM_LINKED_HELP_FILE;
                                helpTopic = CM_HELP_TOPIC;
                            }
                        }
                    }
                    break;

                    case CERTMGR_SAFER_COMPUTER_ROOT:
                    case CERTMGR_SAFER_USER_ROOT:
                    case CERTMGR_SAFER_COMPUTER_LEVELS:
                    case CERTMGR_SAFER_USER_LEVELS:
                    case CERTMGR_SAFER_COMPUTER_ENTRIES:
                    case CERTMGR_SAFER_USER_ENTRIES:
                    case CERTMGR_SAFER_COMPUTER_LEVEL:
                    case CERTMGR_SAFER_USER_LEVEL:
                    case CERTMGR_SAFER_COMPUTER_ENTRY:
                    case CERTMGR_SAFER_USER_ENTRY:
                    case CERTMGR_SAFER_COMPUTER_TRUSTED_PUBLISHERS:
                    case CERTMGR_SAFER_USER_TRUSTED_PUBLISHERS:
                    case CERTMGR_SAFER_COMPUTER_DEFINED_FILE_TYPES:
                    case CERTMGR_SAFER_USER_DEFINED_FILE_TYPES:
                    case CERTMGR_SAFER_COMPUTER_ENFORCEMENT:
                    case CERTMGR_SAFER_USER_ENFORCEMENT:
                        helpFile = SAFER_WINDOWS_LINKED_HELP_FILE;
                        helpTopic = SAFER_HELP_TOPIC;
                        break;

                    case CERTMGR_SNAPIN:
                    default:
                        helpFile = CM_LINKED_HELP_FILE;
                        helpTopic = CM_HELP_TOPIC;
                        break;
                }
            }   


            strHelpTopic += L"\\help\\";
            strHelpTopic += helpFile;
            strHelpTopic += L"::/";
            strHelpTopic += helpTopic;


            hr = spDisplayHelp->ShowTopic ((LPWSTR)(LPCWSTR) strHelpTopic);
        }
        else
            hr = E_FAIL;
    }
    else
    {
        hr = E_UNEXPECTED;
    }

    return hr;
}

HRESULT CCertMgrComponent::SetControlbar(
                    /* [in] */ LPCONTROLBAR /*pControlbar*/)
{
/*
    HRESULT hr = S_OK;

    // if we've got a cached toolbar, release it
    if (m_pToolbar) {
        m_pToolbar->Release();
        m_pToolbar = NULL;
    }

    // if we've got a cached control bar, release it
    if (m_pControlbar) {
        m_pControlbar->Release();
        m_pControlbar = NULL;
    }

    //
    // Install new pieces if necessary
    //

    // if a new one came in, cache and AddRef
    if (pControlbar) 
    {
        m_pControlbar = pControlbar;
        m_pControlbar->AddRef();

        CThemeContextActivator activator;
        hr = m_pControlbar->Create(TOOLBAR,  // type of control
            dynamic_cast<IExtendControlbar *>(this),
            reinterpret_cast<IUnknown **>(&m_pToolbar));

        _ASSERT(SUCCEEDED(hr));
        if ( SUCCEEDED (hr) )
        {
            m_pToolbar->AddRef();

            // add the bitmap to the toolbar
            HBITMAP hbmp = LoadBitmap (MAKEINTRESOURCE(IDR_TOOLBAR1));
            hr = m_pToolbar->AddBitmap (3, hbmp, 16, 16, 
                              RGB(0, 128, 128)); //NOTE, hardcoded value 3

            _ASSERT(SUCCEEDED(hr));

            // Add the buttons to the toolbar
            hr = m_pToolbar->AddButtons(ARRAYLEN(SnapinButtons1), 
                              SnapinButtons1);

            _ASSERT(SUCCEEDED(hr));
        }
    }

    return hr;
*/
    return E_NOTIMPL;
}

HRESULT CCertMgrComponent::ControlbarNotify(
            MMC_NOTIFY_TYPE /*event*/,  // user action
            LPARAM /*arg*/,               // depends on the event parameter
            LPARAM /*param*/)             // depends on the event parameter
{
    return E_NOTIMPL;
}