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

/*++

Copyright (C) 1997-1999 Microsoft Corporation

Module Name:

    cmponent.cpp

Abstract:

    Implementation of the CComponent class.

--*/

#include "StdAfx.h"
#include <shfolder.h>
#include "smcfgmsg.h"
#include "smproppg.h"
//
#include "ctrsprop.h"
#include "fileprop.h"
#include "provprop.h"
#include "schdprop.h"
#include "tracprop.h"
#include "AlrtGenP.h"
#include "AlrtActP.h"
//
#include "newqdlg.h"
#include "ipropbag.h"
#include "smrootnd.h"
#include "smlogs.h"
#include "smtracsv.h"
#include "cmponent.h"


USE_HANDLE_MACROS("SMLOGCFG(cmponent.cpp)")

// These globals are used for dialogs and property sheets
//


#define ARRAYLEN(x) (sizeof(x) / sizeof((x)[0]))

static MMCBUTTON ToolbarResultBtnsLog[] =
{
   { 0, IDM_NEW_QUERY,      TBSTATE_ENABLED,    TBSTYLE_BUTTON, 0, 0 },
   { 0, 0,                  TBSTATE_ENABLED,    TBSTYLE_SEP,    0, 0 },
   { 1, IDM_START_QUERY,    TBSTATE_ENABLED,    TBSTYLE_BUTTON, 0, 0 },
   { 2, IDM_STOP_QUERY,     TBSTATE_ENABLED,    TBSTYLE_BUTTON, 0, 0 }
};

static MMCBUTTON ToolbarResultBtnsAlert[] =
{
   { 0, IDM_NEW_QUERY,      TBSTATE_ENABLED,    TBSTYLE_BUTTON, 0, 0 },
   { 0, 0,                  TBSTATE_ENABLED,    TBSTYLE_SEP,    0, 0 },
   { 1, IDM_START_QUERY,    TBSTATE_ENABLED,    TBSTYLE_BUTTON, 0, 0 },
   { 2, IDM_STOP_QUERY,     TBSTATE_ENABLED,    TBSTYLE_BUTTON, 0, 0 }
};

class CButtonStringsHolder
{
public:
  CButtonStringsHolder()
  {
    m_astr = NULL;
  }
  ~CButtonStringsHolder()
  {
    if (m_astr != NULL)
      delete[] m_astr;
  }
  CString* m_astr; // dynamic array of CStrings
};

CButtonStringsHolder g_astrButtonStringsLog;
CButtonStringsHolder g_astrButtonStringsAlert;

CONST INT cResultBtnsLog = sizeof ( ToolbarResultBtnsLog ) / sizeof ( MMCBUTTON );
CONST INT cResultBtnsAlert = sizeof ( ToolbarResultBtnsAlert ) / sizeof ( MMCBUTTON );

/////////////////////////////////////////////////////////////////////////////
// CComponent

HRESULT 
CComponent::LoadLogToolbarStrings ( MMCBUTTON * Buttons )
{
    UINT i;
    HRESULT hr = S_OK;
    ResourceStateManager rsm;

    if ( NULL != Buttons ) {

        if ( NULL == g_astrButtonStringsLog.m_astr ) {
            // Load strings
            g_astrButtonStringsLog.m_astr = new CString[2*cResultBtnsLog];

            if ( NULL != g_astrButtonStringsLog.m_astr ) {
                for ( i = 0; i < cResultBtnsLog; i++) {
                    // Skip separator buttons
                    if ( 0 != Buttons[i].idCommand ) {
                        UINT iButtonTextId = 0, iTooltipTextId = 0;
    
                        switch (Buttons[i].idCommand)
                        {
                            case IDM_NEW_QUERY:
                                iButtonTextId = IDS_BUTTON_NEW_LOG;
                                iTooltipTextId = IDS_TOOLTIP_NEW_LOG;
                                break;
                            case IDM_START_QUERY:
                                iButtonTextId = IDS_BUTTON_START_LOG;
                                iTooltipTextId = IDS_TOOLTIP_START_LOG;
                                break;
                            case IDM_STOP_QUERY:
                                iButtonTextId = IDS_BUTTON_STOP_LOG;
                                iTooltipTextId = IDS_TOOLTIP_STOP_LOG;
                                break;
                            default:
                                ASSERT(FALSE);
                                break;
                        }

                        g_astrButtonStringsLog.m_astr[i*2].LoadString(iButtonTextId);
                        Buttons[i].lpButtonText =
                        const_cast<BSTR>((LPCTSTR)(g_astrButtonStringsLog.m_astr[i*2]));

                        g_astrButtonStringsLog.m_astr[(i*2)+1].LoadString(iTooltipTextId);
                        Buttons[i].lpTooltipText =
                        const_cast<BSTR>((LPCTSTR)(g_astrButtonStringsLog.m_astr[(i*2)+1]));        
                    }   
                }
            }
        } else {
            hr = E_OUTOFMEMORY;
        }
    } else {
        hr = E_INVALIDARG;
    }
    return hr;
}

HRESULT 
CComponent::LoadAlertToolbarStrings ( MMCBUTTON * Buttons )
{
    HRESULT hr = S_OK;
    UINT i;
    ResourceStateManager rsm;

    if ( NULL == g_astrButtonStringsAlert.m_astr ) {
        // Load strings
        g_astrButtonStringsAlert.m_astr = new CString[2*cResultBtnsAlert];

        if ( NULL != g_astrButtonStringsAlert.m_astr ) {
        
            for ( i = 0; i < cResultBtnsAlert; i++) {
                // Skip separator buttons
                if ( 0 != Buttons[i].idCommand ) {

                  UINT iButtonTextId = 0, iTooltipTextId = 0;
                  switch (Buttons[i].idCommand)
                  {
                  case IDM_NEW_QUERY:
                    iButtonTextId = IDS_BUTTON_NEW_ALERT;
                    iTooltipTextId = IDS_TOOLTIP_NEW_ALERT;
                    break;
                  case IDM_START_QUERY:
                    iButtonTextId = IDS_BUTTON_START_ALERT;
                    iTooltipTextId = IDS_TOOLTIP_START_ALERT;
                    break;
                  case IDM_STOP_QUERY:
                    iButtonTextId = IDS_BUTTON_STOP_ALERT;
                    iTooltipTextId = IDS_TOOLTIP_STOP_ALERT;
                    break;
                  default:
                    ASSERT(FALSE);
                    break;
                  }

                  g_astrButtonStringsAlert.m_astr[i*2].LoadString(iButtonTextId);
                  Buttons[i].lpButtonText =
                    const_cast<BSTR>((LPCTSTR)(g_astrButtonStringsAlert.m_astr[i*2]));

                  g_astrButtonStringsAlert.m_astr[(i*2)+1].LoadString(iTooltipTextId);
                  Buttons[i].lpTooltipText =
                    const_cast<BSTR>((LPCTSTR)(g_astrButtonStringsAlert.m_astr[(i*2)+1]));
                }
            }
        } else {
            hr = E_OUTOFMEMORY;
        }
    } else {
        hr = E_INVALIDARG;
    }
    return hr;
}

CComponent::CComponent()
:   m_ipConsole     ( NULL ),
    m_ipHeaderCtrl  ( NULL ),
    m_ipResultData  ( NULL ),
    m_ipConsoleVerb ( NULL ),
    m_ipImageResult ( NULL ),
    m_ipCompData    ( NULL ),
    m_ipControlbar  ( NULL ),
    m_ipToolbarLogger  ( NULL ),
    m_ipToolbarAlerts  ( NULL ),
    m_ipToolbarAttached  ( NULL ),

    m_pViewedNode   ( NULL )
{
    m_hModule = (HINSTANCE)GetModuleHandleW (_CONFIG_DLL_NAME_W_);

} // end Constructor()

//---------------------------------------------------------------------------
//
CComponent::~CComponent()
{
} // end Destructor()

/////////////////////////////////////////////////////////////////////////////
// IComponent implementation
//

//---------------------------------------------------------------------------
// IComponent::Initialize is called when a snap-in is being created and
// has items in the result pane to enumerate. The pointer to IConsole that
// is passed in is used to make QueryInterface calls to the console for
// interfaces such as IResultData.
//
STDMETHODIMP
CComponent::Initialize (
    LPCONSOLE lpConsole )       // [in] Pointer to IConsole's IUnknown interface
{
    HRESULT hr = E_POINTER;
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    ASSERT( NULL != lpConsole );

    if ( NULL != lpConsole ) {
        // Save away all the interfaces we'll need.
        // Fail if we can't QI the required interfaces.

        m_ipConsole = lpConsole;
        m_ipConsole->AddRef();
        
        hr = m_ipConsole->QueryInterface( 
                            IID_IResultData,
                            (VOID**)&m_ipResultData );
        if ( SUCCEEDED ( hr ) ) {
            hr = m_ipConsole->QueryInterface( 
                                IID_IHeaderCtrl,
                                (VOID**)&m_ipHeaderCtrl );
            if( SUCCEEDED ( hr ) ) {
                m_ipConsole->SetHeader( m_ipHeaderCtrl );
            }

            if ( SUCCEEDED ( hr ) ) {
                hr = m_ipConsole->QueryResultImageList( &m_ipImageResult);
            }

            if ( SUCCEEDED ( hr ) ) {
                hr = m_ipConsole->QueryConsoleVerb( &m_ipConsoleVerb );
            }
        }
    }

    return hr;

} // end Initialize()


//---------------------------------------------------------------------------
//  Handle the most important notifications.
//
STDMETHODIMP
CComponent::Notify (
    LPDATAOBJECT     pDataObject,  // [in] Points to data object
    MMC_NOTIFY_TYPE  event,        // [in] Identifies action taken by user
    LPARAM           arg,          // [in] Depends on the notification type
    LPARAM           Param         // [in] Depends on the notification type
    )
{
    HRESULT hr = S_OK;
    CDataObject* pDO = NULL;
    CSmLogQuery* pQuery = NULL;

    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    ASSERT( NULL != m_ipCompData );  

    switch( event ) {
    case MMCN_ADD_IMAGES:
        hr = OnAddImages( pDataObject, arg, Param );
        break;

    case MMCN_DELETE:
        hr = OnDelete ( pDataObject, arg, Param );
        break;

    case MMCN_PASTE:
        LOCALTRACE( _T("CComponent::Notify: MMCN_PASTE unimplemented\n") );
        /*
        hr = OnPaste( pDataObject, arg, Param );
        */
        break;

    case MMCN_QUERY_PASTE:
        LOCALTRACE( _T("CComponent::Notify: MMCN_QUERY_PASTE unimplemented\n") );
        /*
        hr = OnQueryPaste( pDataObject, arg, Param );
        */
        break;

    case MMCN_REFRESH:
        hr = OnRefresh( pDataObject );
        break;

    case MMCN_SELECT:
        hr = OnSelect( pDataObject, arg, Param );
        break;

    case MMCN_SHOW:
        hr = OnShow( pDataObject, arg, Param );
        break;

    case MMCN_VIEW_CHANGE:
        hr = OnViewChange( pDataObject, arg, Param );
        break;

    case MMCN_PROPERTY_CHANGE:

        if ( NULL != Param ) {
            // Data object is passed as parameter
            hr = OnViewChange( (LPDATAOBJECT)Param, arg, CComponentData::eSmHintModifyQuery );
        } else {
            hr = S_FALSE;
        }
        break;

    case MMCN_CLICK:
        LOCALTRACE( _T("CComponent::Notify: MMCN_CLICK unimplemented\n") );
        break;

    case MMCN_DBLCLICK:
        pDO = ExtractOwnDataObject(pDataObject);
        if ( NULL != pDO ) {
            hr = (HRESULT) OnDoubleClick ((ULONG) pDO->GetCookie(),pDataObject);
        } else { 
            hr = S_FALSE;
        }
        break;

    case MMCN_ACTIVATE:
        LOCALTRACE( _T("CComponent::Notify: MMCN_ACTIVATE unimplemented\n") );
        break;

    case MMCN_MINIMIZED:
        LOCALTRACE( _T("CComponent::Notify: MMCN_MINIMIZED unimplemented\n") );
        break;

    case MMCN_BTN_CLICK:
        LOCALTRACE( _T("CComponent::Notify: MMCN_BTN_CLICK unimplemented\n") );
        break;

    case MMCN_CONTEXTHELP:
        hr = OnDisplayHelp( pDataObject );
        break;

    default:
        LOCALTRACE( _T("CComponent::Notify: unimplemented event %x\n"), event );
        hr = S_FALSE;
        break;
    }
    return hr;

} // end Notify()


//---------------------------------------------------------------------------
// Releases all references to the console.
// Only the console should call this method.
//
STDMETHODIMP
CComponent::Destroy (
    MMC_COOKIE     /* mmcCookie */         // Reserved, not in use at this time
    )
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    // Release the interfaces that we QI'ed
    m_ipConsole->SetHeader(NULL);

    SAFE_RELEASE( m_ipHeaderCtrl  );
    SAFE_RELEASE( m_ipResultData  );
    SAFE_RELEASE( m_ipImageResult );
    SAFE_RELEASE( m_ipConsoleVerb );
    SAFE_RELEASE( m_ipConsole     );
    SAFE_RELEASE( m_ipControlbar  );
    SAFE_RELEASE( m_ipToolbarLogger );
    SAFE_RELEASE( m_ipToolbarAlerts );

    return S_OK;

} // end Destroy()


//---------------------------------------------------------------------------
// Returns a data object that can be used to retrieve context information
// for the specified mmcCookie.
//
STDMETHODIMP
CComponent::QueryDataObject (
    MMC_COOKIE         mmcCookie,   // [in]  Specifies the unique identifier
    DATA_OBJECT_TYPES  context,     // [in]  Type of data object
    LPDATAOBJECT*      ppDataObject // [out] Points to address of returned data
    )
{
    HRESULT hr = S_OK;
    BOOL bIsQuery = FALSE;
    CComObject<CDataObject>* pDataObj = NULL;
    CSmLogQuery* pQuery = NULL;
    INT iResult;
    CString strMessage;
    ResourceStateManager    rsm;
    
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    
    ASSERT( CCT_SCOPE == context                // Must have a context
            || CCT_RESULT == context            // we understand
            || CCT_SNAPIN_MANAGER == context );

    ASSERT( NULL != m_ipCompData );  

    if ( NULL != ppDataObject 
        && ( CCT_SCOPE == context                // Must have a context
                || CCT_RESULT == context            // we understand
                || CCT_SNAPIN_MANAGER == context ) ) {

        if( CCT_RESULT == context && NULL != mmcCookie ) {
            CComObject<CDataObject>::CreateInstance( &pDataObj );
            if( NULL == pDataObj ) {             // DataObject was not created
                MFC_TRY
                    strMessage.LoadString( IDS_ERRMSG_OUTOFMEMORY );
                MFC_CATCH_HR
                hr = m_ipConsole->MessageBox( strMessage,
                    _T("CComponent::QueryDataObject"), // not localized
                    MB_OK | MB_ICONERROR,
                    &iResult
                    );
                hr = E_OUTOFMEMORY;
            } else {
                // Now we have a data object, init the mmcCookie, context and type
                bIsQuery = m_ipCompData->IsLogQuery (mmcCookie);

                if ( bIsQuery ) {
                    pQuery = (CSmLogQuery*)mmcCookie;
                    ASSERT ( NULL != pQuery );
                    if ( NULL != pQuery ) {
                        if ( CComponentData::eCounterLog == pQuery->GetLogType() ) {
                            pDataObj->SetData( mmcCookie, CCT_RESULT, COOKIE_IS_COUNTERMAINNODE );
                        } else if ( CComponentData::eTraceLog == pQuery->GetLogType() ) {
                            pDataObj->SetData( mmcCookie, CCT_RESULT, COOKIE_IS_TRACEMAINNODE );
                        } else if ( CComponentData::eAlert == pQuery->GetLogType() ) {
                            pDataObj->SetData( mmcCookie, CCT_RESULT, COOKIE_IS_ALERTMAINNODE );
                        } else {
                            ::MessageBox( NULL,
                                _T("Bad Cookie"),
                                _T("CComponentData::QueryDataObject"),
                                MB_OK | MB_ICONERROR
                                );
                            hr = E_OUTOFMEMORY;
                        }
                    }                 
                } else {
                    if  ( m_ipCompData->IsScopeNode( mmcCookie ) ) {
                        if ( NULL != (reinterpret_cast<PSMNODE>(mmcCookie))->CastToRootNode() ) {
                            pDataObj->SetData(mmcCookie, CCT_RESULT, COOKIE_IS_ROOTNODE);
                        } else {
                            ::MessageBox( NULL,
                                _T("Bad Cookie"),
                                _T("CComponentData::QueryDataObject"),
                                MB_OK | MB_ICONERROR
                                );
                            hr = E_OUTOFMEMORY;
                        }
                    }
                }
            }
        } else if ((CCT_SNAPIN_MANAGER == context) && (NULL != mmcCookie)) {
            // this is received by the snap in when it is added
            // as an extension snap ine
            CComObject<CDataObject>::CreateInstance( &pDataObj );
            if( NULL == pDataObj ) {            // DataObject was not created
                MFC_TRY
                    strMessage.LoadString( IDS_ERRMSG_OUTOFMEMORY );
                MFC_CATCH_HR
                hr = m_ipConsole->MessageBox( strMessage,
                    _T("CComponent::QueryDataObject"),  // not localized
                    MB_OK | MB_ICONERROR,
                    &iResult
                    );
                hr = E_OUTOFMEMORY;
            } else {
                // Now we have a data object, init the mmcCookie, context and type
                pDataObj->SetData( mmcCookie, CCT_SNAPIN_MANAGER, COOKIE_IS_MYCOMPUTER );
            }
        } else {                                // Request must have been from an
                                                // unknown source.  Should never see
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        }

        if ( SUCCEEDED ( hr ) ) {
            hr = pDataObj->QueryInterface( IID_IDataObject,
                reinterpret_cast<void**>(ppDataObject) );
        } else {
            if ( NULL != pDataObj ) {
                delete pDataObj;
            }
            *ppDataObject = NULL;
        }
    } else {
        hr = E_POINTER;
    }

    return hr;
} // end QueryDataObject()


//---------------------------------------------------------------------------
// This is where we provide strings for items we added to the the result
// pane.  We get asked for a string for each column.
// Note that we still need to provide strings for items that are actually
// scope pane items. Notice that when the scope pane item was asked for a
// string for the scope pane we gave it. Here we actually have two columns
// of strings - "Name" and "Type".
// We also get asked for the icons for items in both panes.
//

STDMETHODIMP
CComponent::GetDisplayInfo (
    LPRESULTDATAITEM pResultItem )  // [in,out] Type of info required
{
    HRESULT     hr = S_OK;
    PSLQUERY    pQuery;
    CSmNode*    pNode;
    PSROOT      pRoot;
    PSLSVC      pSvc;
    WCHAR       szErrorText[MAX_PATH];
    ResourceStateManager    rsm;
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    if ( NULL == pResultItem ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        if( FALSE == pResultItem->bScopeItem ) {  // Doing result items...
            if( pResultItem->mask & RDI_STR ) {   // Now we have a object
                // Note:  Text buffer allocated for each information type, so that
                // the buffer pointer is persistent for a single item (line in the result pane).

                MFC_TRY

                switch (pResultItem->nCol) {
                case ROOT_COL_QUERY_NAME:
                    pQuery = reinterpret_cast<PSLQUERY>(pResultItem->lParam);
                    m_strDisplayInfoName = pQuery->GetLogName ( );
                    pResultItem->str = T2OLE ( m_strDisplayInfoName.GetBuffer( 0 ) );
                    m_strDisplayInfoName.ReleaseBuffer( );
                    break;

                case ROOT_COL_COMMENT:
                    pQuery= reinterpret_cast<PSLQUERY>(pResultItem->lParam);
                    m_strDisplayInfoComment = pQuery->GetLogComment ( );
                    pResultItem->str = T2OLE ( m_strDisplayInfoComment.GetBuffer( 0 ) );
                    m_strDisplayInfoComment.ReleaseBuffer( );
                    break;

                case ROOT_COL_LOG_TYPE:
                    pQuery= reinterpret_cast<PSLQUERY>(pResultItem->lParam);
                    // Query type should not be Alert
                    ASSERT ( SLQ_ALERT != pQuery->GetLogType() );
                    m_strDisplayInfoLogFileType =  pQuery->GetLogFileType ( );
                    pResultItem->str = T2OLE ( m_strDisplayInfoLogFileType.GetBuffer( 0 ) );
                    m_strDisplayInfoLogFileType.ReleaseBuffer( );
                    break;

                case ROOT_COL_LOG_NAME:
                    pQuery= reinterpret_cast<PSLQUERY>(pResultItem->lParam);
                    // Query type should not be Alert
                    ASSERT ( SLQ_ALERT != pQuery->GetLogType() );
                    m_strDisplayInfoLogFileName = pQuery->GetLogFileName ();
                    pResultItem->str = T2OLE ( m_strDisplayInfoLogFileName.GetBuffer( 0 ) );
                    m_strDisplayInfoLogFileName.ReleaseBuffer( );
                    break;

                default:
                    swprintf (szErrorText, _T("Error: Column %d Selected for Result Item\n"),
                              pResultItem->nCol);
                    ASSERT ( FALSE );
                    LOCALTRACE( szErrorText );
                    hr = E_UNEXPECTED;
                }

                MFC_CATCH_HR 
            }

            if (pResultItem->mask & RDI_IMAGE) {
                pQuery= reinterpret_cast<PSLQUERY>(pResultItem->lParam);
                if ( NULL != pQuery ) {
                    pResultItem->nImage = (pQuery->IsRunning() ? 0 : 1);
                } else {
                    ASSERT ( FALSE );
                    hr = E_UNEXPECTED;
                }
            }
        }
        else  // TRUE == pResultItem->bScopeItem
        {
            pNode = reinterpret_cast<CSmNode*>(pResultItem->lParam);

            if( pResultItem->mask & RDI_STR ) {
                if ( pNode->CastToRootNode() ) {

                    MFC_TRY

                    pRoot = reinterpret_cast<PSROOT>(pResultItem->lParam);

                    switch ( pResultItem->nCol ) {
                    case EXTENSION_COL_NAME:
                        m_strDisplayInfoName = pRoot->GetDisplayName();
                        pResultItem->str = T2OLE ( m_strDisplayInfoName.GetBuffer( 0 ) );
                        m_strDisplayInfoName.ReleaseBuffer( );
                        break;

                    case EXTENSION_COL_TYPE:
                        m_strDisplayInfoQueryType = pRoot->GetType();
                        pResultItem->str = T2OLE ( m_strDisplayInfoQueryType.GetBuffer( 0 ) );
                        m_strDisplayInfoQueryType.ReleaseBuffer( );
                        break;

                    case EXTENSION_COL_DESC:
                        m_strDisplayInfoDesc = pRoot->GetDescription();
                        pResultItem->str = T2OLE ( m_strDisplayInfoDesc.GetBuffer( 0 ) );
                        m_strDisplayInfoDesc.ReleaseBuffer( );
                        break;

                    default:
                        swprintf (szErrorText, _T("Error: Column %d Selected for Scope item\n"),
                            pResultItem->nCol);
                        ASSERT ( FALSE );
                        LOCALTRACE( szErrorText );
                        hr = E_UNEXPECTED;
                    }
                    
                    MFC_CATCH_HR
                } else {

                    ASSERT ( pNode->CastToLogService() );

                    MFC_TRY

                    if( pResultItem->nCol == MAIN_COL_NAME ) {
                        pSvc = reinterpret_cast<PSLSVC>(pResultItem->lParam);
                        m_strDisplayInfoName = pSvc->GetDisplayName();
                        pResultItem->str = T2OLE ( m_strDisplayInfoName.GetBuffer( 0 ) );
                        m_strDisplayInfoName.ReleaseBuffer( );
                    } else if( pResultItem->nCol == MAIN_COL_DESC ) {
                        pSvc = reinterpret_cast<PSLSVC>(pResultItem->lParam);
                        m_strDisplayInfoDesc = pSvc->GetDescription();
                        pResultItem->str = T2OLE ( m_strDisplayInfoDesc.GetBuffer( 0 ) );
                        m_strDisplayInfoDesc.ReleaseBuffer( );
                    } else {
                        swprintf (szErrorText, _T("Error: Column %d Selected for Scope item\n"),
                            pResultItem->nCol);
                        ASSERT ( FALSE );
                        LOCALTRACE( szErrorText );
                        hr = E_UNEXPECTED;
                    }

                    MFC_CATCH_HR
                }
            }

            if (pResultItem->mask & RDI_IMAGE)
            {
                CSmNode* pNode = reinterpret_cast<PSMNODE>(pResultItem->lParam);

                if ( NULL != pNode->CastToRootNode() ) {
                    pResultItem->nImage = CComponentData::eBmpRootIcon;
                } else if ( NULL != pNode->CastToAlertService() ) {
                    pResultItem->nImage = CComponentData::eBmpAlertType;
                } else {
                    pResultItem->nImage = CComponentData::eBmpLogType;
                }
            }
        }
    }

    return hr;

} // end GetDisplayInfo()


//---------------------------------------------------------------------------
// Determines what the result pane view should be
//
STDMETHODIMP
CComponent::GetResultViewType (
    MMC_COOKIE  /* mmcCookie */,        // [in]  Specifies the unique identifier
    BSTR  * /* ppViewType */,   // [out] Points to address of the returned view type
    long  *pViewOptions  // [out] Pointer to the MMC_VIEW_OPTIONS enumeration
    )
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    // Ask for default listview.
    *pViewOptions = MMC_VIEW_OPTIONS_NONE;
    return S_FALSE;

} // end GetResultViewType()


//---------------------------------------------------------------------------
// Not used
//
HRESULT
CComponent::CompareObjects (
    LPDATAOBJECT /* lpDataObjectA */,  // [in] First data object to compare
    LPDATAOBJECT /* lpDataObjectB */  // [in] Second data object to compare
    )
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    return S_FALSE;

} // end CompareObjects()


/////////////////////////////////////////////////////////////////////////////
//  Support methods
//

//---------------------------------------------------------------------------
// Here is where we handle the MMCN_SHOW message.  Insert the column
// headers, and then the rows of data into the result pane.
//
HRESULT
CComponent::OnShow (
    LPDATAOBJECT pDataObject,    // [in] Points to data object
    LPARAM       Arg,            // [in]
    LPARAM       /* Param */ )   // [in] not used
{
    HRESULT         hr = S_OK;
    CDataObject*    pDO = NULL;
    CString         strColHeader;
    INT             iCommentSize;

    ResourceStateManager rsm;

    ASSERT( NULL != m_ipResultData );

    if ( TRUE == Arg ) {
    
        if ( NULL == pDataObject ) {
            ASSERT ( FALSE );
            hr = E_POINTER;
        } else {
            pDO = ExtractOwnDataObject(pDataObject);
            if ( NULL == pDO ) {
                ASSERT ( FALSE );
                hr = E_UNEXPECTED;
            }
        }
        if ( SUCCEEDED ( hr ) ) {
            m_pViewedNode = (CSmNode*)pDO->GetCookie();

            if( !(COOKIE_IS_ROOTNODE == pDO->GetCookieType() ) ) {

                // Query name
                MFC_TRY
                    strColHeader.LoadString ( IDS_ROOT_COL_QUERY_NAME );
                MFC_CATCH_HR

                hr = m_ipHeaderCtrl->InsertColumn(  
                        ROOT_COL_QUERY_NAME,
                        strColHeader,
                        LVCFMT_LEFT,
                        ROOT_COL_QUERY_NAME_SIZE );
                ASSERT( S_OK == hr );

                // Comment
                STANDARD_TRY
                    strColHeader.LoadString ( IDS_ROOT_COL_COMMENT );
                MFC_CATCH_HR

                iCommentSize = ROOT_COL_COMMENT_SIZE;
            
                if ( COOKIE_IS_ALERTMAINNODE == pDO->GetCookieType() ) {
                     iCommentSize += ROOT_COL_ALERT_COMMENT_XTRA;
                }

                hr = m_ipHeaderCtrl->InsertColumn(  
                        ROOT_COL_COMMENT,
                        strColHeader,
                        LVCFMT_LEFT,
                        iCommentSize);
                ASSERT( S_OK == hr );

                // Log type
                if ( COOKIE_IS_COUNTERMAINNODE == pDO->GetCookieType()
                    || COOKIE_IS_TRACEMAINNODE == pDO->GetCookieType() ) {

                    STANDARD_TRY
                        strColHeader.LoadString ( IDS_ROOT_COL_LOG_TYPE );
                    MFC_CATCH_HR

                    hr = m_ipHeaderCtrl->InsertColumn(  
                            ROOT_COL_LOG_TYPE,
                            strColHeader,
                            LVCFMT_LEFT,
                            ROOT_COL_LOG_TYPE_SIZE);
                    ASSERT( S_OK == hr );

                    STANDARD_TRY
                        strColHeader.LoadString ( IDS_ROOT_COL_LOG_FILE_NAME );
                    MFC_CATCH_HR

                    hr = m_ipHeaderCtrl->InsertColumn(  
                            ROOT_COL_LOG_NAME,
                            strColHeader,
                            LVCFMT_LEFT,
                            ROOT_COL_LOG_NAME_SIZE);
                    ASSERT( S_OK == hr );
                }

                // Set the items in the results pane rows
                ASSERT( CCT_SCOPE == pDO->GetContext() );
                ASSERT( COOKIE_IS_COUNTERMAINNODE == pDO->GetCookieType()
                        || COOKIE_IS_TRACEMAINNODE == pDO->GetCookieType()
                        || COOKIE_IS_ALERTMAINNODE == pDO->GetCookieType() );


                // The lParam is what we see in QueryDataObject as the mmcCookie.
                // Now we have an object representing row data, so that the
                // mmcCookie knows what to display in the results pane, when we
                // get into GetDisplayInfo we cast the mmcCookie to our object,
                // and then we can get the data to display.
                //
                hr = PopulateResultPane( pDO->GetCookie() );
            } else {

                MFC_TRY
                    strColHeader.LoadString ( IDS_MAIN_COL_NODE_NAME );
                MFC_CATCH_HR

                // Set the column headers in the results pane
                hr = m_ipHeaderCtrl->InsertColumn(  
                        MAIN_COL_NAME,
                        strColHeader,
                        LVCFMT_LEFT,
                        MAIN_COL_NAME_SIZE);
                ASSERT( S_OK == hr );

                STANDARD_TRY
                    strColHeader.LoadString ( IDS_MAIN_COL_NODE_DESCRIPTION );
                MFC_CATCH_HR

                hr = m_ipHeaderCtrl->InsertColumn(  
                        MAIN_COL_DESC,
                        strColHeader,
                        LVCFMT_LEFT,
                        MAIN_COL_DESC_SIZE);
                ASSERT( S_OK == hr );
            }
        }
    } else {
        m_pViewedNode = NULL;
    }
    return hr;

} // end OnShow()

//---------------------------------------------------------------------------
//
HRESULT
CComponent::OnAddImages (
    LPDATAOBJECT /* pDataObject */,  // [in] Points to the data object
    LPARAM /* arg */,                  // [in] Not used
    LPARAM /* param */                // [in] Not used
    )
{
    HRESULT hr = S_FALSE;
    ASSERT( NULL != m_ipImageResult );

    HBITMAP hbmp16x16 = NULL;
    HBITMAP hbmp32x32 = NULL;

    if ( NULL != g_hinst && NULL != m_ipImageResult ) {
        hbmp16x16 = LoadBitmap(g_hinst, MAKEINTRESOURCE(IDB_NODES_16x16));
        hbmp32x32 = LoadBitmap(g_hinst, MAKEINTRESOURCE(IDB_NODES_32x32));

        hr = m_ipImageResult->ImageListSetStrip(
            (LONG_PTR *)hbmp16x16,
            (LONG_PTR *)hbmp32x32,
            0,
            RGB(0,255,0)
            );

        ASSERT( S_OK == hr );

        if ( NULL != hbmp16x16 ) 
        {
            DeleteObject (hbmp16x16);
        }

        if ( NULL != hbmp32x32 ) 
        {
            DeleteObject (hbmp32x32);
        }
    }
    return hr;

} // end OnAddImages()

//---------------------------------------------------------------------------
//  This is a handler for the MMCN_PASTE notification. The user
//  copied a node to the clipboard.  Paste the counters from the data object
//  into the currently selected node.
//
HRESULT
CComponent::OnPaste (
    LPDATAOBJECT   pDataObject,  // [in] Points to the data object
    LPARAM         arg,          // [in] Points to source data object
    LPARAM     /*  param  */     // [in] Not used
    )
{
    HRESULT hr = S_FALSE;
    CDataObject* pDO = NULL;
    CDataObject* pDOSource = NULL;
    BOOL bIsQuery = FALSE;

    ASSERT( NULL != m_ipCompData );  

    if ( NULL == pDataObject ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        pDO = ExtractOwnDataObject(pDataObject);
    }

    if ( SUCCEEDED ( hr ) ) {
        // Bail if we couldn't get the console verb interface, or if the
        // selected item is the root;
        if ( NULL == (LPDATAOBJECT)arg ) {
            ASSERT ( FALSE );
            hr = E_INVALIDARG;
        } else {
            pDOSource = ExtractOwnDataObject((LPDATAOBJECT)arg);
        }
    }

    if ( SUCCEEDED ( hr ) && NULL != pDO && NULL != pDOSource ) {
        bIsQuery = m_ipCompData->IsLogQuery (pDO->GetCookie())
                    && m_ipCompData->IsLogQuery (pDOSource->GetCookie());
        // Note: Can't check with compdata to determine if query, because
        // can be from another compdata

        if ( bIsQuery )
            hr = S_OK;
    }
    return hr;
} // end OnPaste()

//---------------------------------------------------------------------------
//  This is a handler for the MMCN_QUERY_PASTE notification. The user
//  copied a node to the clipboard.  Determine if that data object
//  can be pasted into the currently selected node.
//
HRESULT
CComponent::OnQueryPaste (
    LPDATAOBJECT   pDataObject,  // [in] Points to the data object
    LPARAM         arg,          // [in] Points to source data object
    LPARAM     /*  param  */ )   // [in] Not used
{
    HRESULT hr = S_FALSE;
    CDataObject* pDO = NULL;
    CDataObject* pDOSource = NULL;
    BOOL bIsQuery = FALSE;
    BOOL bState;

    ASSERT( NULL != m_ipCompData );  

    // Bail if we couldn't get the console verb interface, or if the
    // selected item is the root;
    if ( NULL == pDataObject ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        pDO = ExtractOwnDataObject(pDataObject);
    }

    if ( SUCCEEDED ( hr ) ) {
        if ( NULL == (LPDATAOBJECT)arg ) {
            ASSERT ( FALSE );
            hr = E_INVALIDARG;
        } else {
            pDOSource = ExtractOwnDataObject((LPDATAOBJECT)arg);
        }
    }

    if ( SUCCEEDED ( hr) && NULL != pDO && NULL != pDOSource ) {
        bIsQuery = m_ipCompData->IsLogQuery (pDO->GetCookie());

        if ( bIsQuery ) {
            hr = m_ipConsoleVerb->GetVerbState ( MMC_VERB_PASTE, ENABLED, &bState );
            hr = m_ipConsoleVerb->SetVerbState( MMC_VERB_PASTE, ENABLED, TRUE );
            hr = m_ipConsoleVerb->GetVerbState ( MMC_VERB_PASTE, ENABLED, &bState );
            ASSERT( S_OK == hr );

            hr = S_OK;
        }
    }
    return hr;
} // end OnQueryPaste()

//---------------------------------------------------------------------------
//  This is a handler for the MMCN_SELECT notification. The user
//  selected the node that populated the result pane. We have a
//  chance to enable verbs.
//
HRESULT
CComponent::OnSelect (
    LPDATAOBJECT   pDataObject,  // [in] Points to the data object
    LPARAM         arg,          // [in] Contains flags about the selected item
    LPARAM     /*  param  */ )   // [in] Not used
{
    HRESULT     hr = S_OK;
    BOOL        fScopePane;
    BOOL        fSelected;
    CDataObject* pDO = NULL;
    MMC_COOKIE  mmcCookie = 0;
    BOOL    bIsQuery = FALSE;
    CSmNode* pNode = NULL;
    PSLQUERY pQuery = NULL;

    ASSERT( NULL != m_ipCompData );  

    if ( NULL == pDataObject ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        pDO = ExtractOwnDataObject(pDataObject);
        if ( NULL == pDO ) {
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        }
    }

    if ( SUCCEEDED ( hr ) ) {
        // Bail if we couldn't get the console verb interface, or if the
        // selected item is the root;
        if( NULL == m_ipConsoleVerb || COOKIE_IS_ROOTNODE == pDO->GetCookieType() ) {
            hr = S_OK;
        } else {

            // Use selections and set which verbs are allowed

            fScopePane = LOWORD(arg);
            fSelected  = HIWORD(arg);

            if( fScopePane ) {                    // Selection in the scope pane
                // Enabled refresh for main node type, only if that node type is currently
                // being viewed in the result pane.
                if ( fSelected ) {
                    if ( COOKIE_IS_COUNTERMAINNODE == pDO->GetCookieType()
                                || COOKIE_IS_TRACEMAINNODE == pDO->GetCookieType()
                                || COOKIE_IS_ALERTMAINNODE == pDO->GetCookieType() ) {
                        if ( NULL != m_pViewedNode ) {
                            if ( m_pViewedNode == (CSmNode*)pDO->GetCookie() ) {
                                hr = m_ipConsoleVerb->SetVerbState( MMC_VERB_REFRESH, ENABLED, TRUE );
                                ASSERT( S_OK == hr );
                            }
                        }
                    }
                }
            } else {                                 
                // Selection in the result pane
                // Properties is default verb

                if ( COOKIE_IS_COUNTERMAINNODE == pDO->GetCookieType()
                            || COOKIE_IS_TRACEMAINNODE == pDO->GetCookieType()
                            || COOKIE_IS_ALERTMAINNODE == pDO->GetCookieType() ) {
                    if ( NULL != m_pViewedNode ) {
                        mmcCookie = (MMC_COOKIE)pDO->GetCookie();

                        bIsQuery = m_ipCompData->IsLogQuery (mmcCookie);

                        if ( bIsQuery ) {
                            pQuery = (PSLQUERY)pDO->GetCookie();
                            if ( NULL != pQuery ) {
                                pNode = (CSmNode*)pQuery->GetLogService();
                            }
                        } else {
                            pNode = (CSmNode*)pDO->GetCookie();
                        }

                        if ( NULL != m_pViewedNode && m_pViewedNode == pNode ) {
                            hr = m_ipConsoleVerb->SetVerbState( MMC_VERB_REFRESH, ENABLED, TRUE );
                            ASSERT( S_OK == hr );
                        }
                    }
                }

                if ( fSelected ) {
                    hr = m_ipConsoleVerb->SetDefaultVerb( MMC_VERB_PROPERTIES );
                    ASSERT( S_OK == hr );

                    // Enable properties and delete verbs
                    hr = m_ipConsoleVerb->SetVerbState( MMC_VERB_PROPERTIES, ENABLED, TRUE );
                    ASSERT( S_OK == hr );
                    hr = m_ipConsoleVerb->SetVerbState( MMC_VERB_DELETE, ENABLED, TRUE );
                    ASSERT( S_OK == hr );
/*
                    // Enable copying and pasting the object
                    hr = m_ipConsoleVerb->SetVerbState( MMC_VERB_COPY, ENABLED, TRUE );
                    ASSERT( S_OK == hr );
                    hr = m_ipConsoleVerb->SetVerbState( MMC_VERB_PASTE, HIDDEN, FALSE );
                    hr = m_ipConsoleVerb->SetVerbState( MMC_VERB_PASTE, ENABLED, FALSE );
                    ASSERT( S_OK == hr );
                } else {
                    hr = m_ipConsoleVerb->SetVerbState( MMC_VERB_PASTE, HIDDEN, FALSE );
                    hr = m_ipConsoleVerb->SetVerbState( MMC_VERB_PASTE, ENABLED, FALSE );
                    ASSERT( S_OK == hr );
*/
                }
            }
            hr = S_OK;
        }
    }

    return hr;

} // end OnSelect()


//---------------------------------------------------------------------------
//  Respond to the MMCN_REFRESH notification and refresh the rows.
//
HRESULT
CComponent::OnRefresh (
    LPDATAOBJECT pDataObject )  // [in] Points to the data object
{
    HRESULT hr = S_OK;
    CDataObject* pDO = NULL;
    
    ASSERT( NULL != m_ipResultData );
    
    if ( NULL == pDataObject ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        pDO = ExtractOwnDataObject(pDataObject);
        if ( NULL == pDO ) {
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        }
    }

    if ( SUCCEEDED ( hr ) ) {
        // If this is the root node, don't need to do anything
        if( COOKIE_IS_ROOTNODE == pDO->GetCookieType() ) {
            hr = S_FALSE;
        } else {
            // Refresh the data model and update the result pane.
            // Use the stored pointer to the known viewed node, to handle the
            // case where the result pane contains scope nodes, and to handle
            // the case where the cookie is a query.
            if ( NULL != m_pViewedNode ) {
                hr = RefreshResultPane( (MMC_COOKIE) m_pViewedNode);
            }
            // RefreshResultPane cancels any selection.
            hr = HandleExtToolbars( TRUE, (LPARAM)0, (LPARAM)pDataObject );
        }
    }
    return hr;
} // end OnRefresh()

//---------------------------------------------------------------------------
//  Respond to the MMCN_VIEW_CHANGE notification and refresh as specified.
//
HRESULT
CComponent::OnViewChange (
    LPDATAOBJECT   pDataObject,  // [in] Points to the data object
    LPARAM         /* arg */,    // [in] Not used
    LPARAM         param )       // [in] Contains view change hint
{
    HRESULT hr = S_OK;
    CDataObject* pDO = NULL;

    ASSERT( NULL != m_ipCompData );  

    if ( NULL == pDataObject ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        pDO = ExtractOwnDataObject(pDataObject);
        if ( NULL == pDO ) {
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        }
    }

    if ( SUCCEEDED ( hr ) ) {
        if ( m_ipCompData->IsLogService ( pDO->GetCookie() ) 
            && CComponentData::eSmHintNewQuery == param ) {
            hr = OnRefresh( pDataObject );
        } else {
            hr = S_FALSE;
            if ( CCT_RESULT == pDO->GetContext() ) {
                HRESULTITEM hItemID = NULL;
                PSLQUERY    pSlQuery = reinterpret_cast<PSLQUERY>(pDO->GetCookie());

                ASSERT ( NULL != m_ipResultData );
                if ( NULL != pSlQuery ) {
                    // Redraw the item.
                    hr = m_ipResultData->FindItemByLParam ( (LPARAM)pSlQuery, &hItemID );
                    if ( SUCCEEDED(hr) ) {
                        hr = m_ipResultData->UpdateItem  ( hItemID );
                    }
                }

                // Sync the toolbar start/stop buttons.
                // 0 second arg indicates result scope.
                hr = HandleExtToolbars( FALSE, (LPARAM)0, (LPARAM)pDataObject );
            }
        }
    }
    return hr;
}

//---------------------------------------------------------------------------
//          Implementing a handler for MMCN_PROPERTY_CHANGE.
//          Param is the address of the PROPCHANGE struct that originally
//          came from the PropertySheet via MMCPropertyChangeNotify()
//
HRESULT
CComponent::OnPropertyChange (
    LPARAM     /*  param  */   // [in] PROPCHANGE_DATA struct with new data
    )
{

    return S_OK;
} // end OnPropertyChange()

//---------------------------------------------------------------------------
//  Store the parent IComponetData object.
//
HRESULT
CComponent::SetIComponentData (
    CComponentData*  pData )    // [in] Parent CComponentData object
{
    HRESULT hr = E_POINTER;
    LPUNKNOWN pUnk = NULL;

    ASSERT( NULL == m_ipCompData );        // Can't do this twice

    if ( NULL != pData ) {
        pUnk = pData->GetUnknown();  // Get the object IUnknown

        if ( NULL != pUnk ) {
            hr = pUnk->QueryInterface( IID_IComponentData,
                    reinterpret_cast<void**>(&m_ipCompData) );
        } else {
            hr = E_UNEXPECTED;
        }
    }
    return hr;
} // end SetIComponentData()

//---------------------------------------------------------------------------
//  Respond to the MMCN_CONTEXTHELP notification.
//
HRESULT
CComponent::OnDisplayHelp (
    LPDATAOBJECT /* pDataObject */ )  // [in] Points to the data object
{
    HRESULT hr = E_FAIL;
    IDisplayHelp* pDisplayHelp;
    CString strTopicPath;
    LPOLESTR pCompiledHelpFile = NULL;
    UINT    nBytes;
    
    USES_CONVERSION;

    ASSERT( NULL != m_ipCompData );  

    hr = m_ipConsole->QueryInterface(IID_IDisplayHelp, reinterpret_cast<void**>(&pDisplayHelp));
    
    if ( SUCCEEDED(hr) ) {
        MFC_TRY
            // construct help topic path = (help file::topic string)
            strTopicPath = m_ipCompData->GetConceptsHTMLHelpFileName(); 

            strTopicPath += _T("::/");
            strTopicPath += m_ipCompData->GetHTMLHelpTopic();           // sample.chm::/helptopic.htm

            nBytes = (strTopicPath.GetLength()+1) * sizeof(WCHAR);
            pCompiledHelpFile = (LPOLESTR)::CoTaskMemAlloc(nBytes);

            if ( NULL == pCompiledHelpFile ) {
                hr = E_OUTOFMEMORY;
            } else {
                memcpy(pCompiledHelpFile, (LPCTSTR)strTopicPath, nBytes);

                hr = pDisplayHelp->ShowTopic(T2W(pCompiledHelpFile));
                
                ::CoTaskMemFree ( pCompiledHelpFile );

                pDisplayHelp->Release();
            }
        MFC_CATCH_HR
    }
    return hr;
} // end OnDisplayHelp()

/////////////////////////////////////////////////////////////////////////////
//  IExtendContextMenu methods
//

//---------------------------------------------------------------------------
//  Implement some context menu items
//
STDMETHODIMP
CComponent::AddMenuItems (
    LPDATAOBJECT           pDataObject,         // [in] Points to data object
    LPCONTEXTMENUCALLBACK  pCallbackUnknown,    // [in] Points to callback function
    long*                  pInsertionAllowed )  // [in,out] Insertion flags
{
    HRESULT hr = S_OK;
    static CONTEXTMENUITEM ctxMenu[3];
    CDataObject* pDO = NULL;
    CString strTemp1, strTemp2, strTemp3, strTemp4, strTemp5, strTemp6;
    CSmLogQuery* pQuery;
    ResourceStateManager    rsm;
    
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    ASSERT( NULL != m_ipCompData );  

    if ( NULL == pDataObject ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        pDO = ExtractOwnDataObject( pDataObject );
        if ( NULL == pDO ) {
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        }
    }

    if ( SUCCEEDED ( hr ) ) {
        // Only add menu items when we are allowed to.
        if ( ( COOKIE_IS_COUNTERMAINNODE == pDO->GetCookieType() )
                || ( COOKIE_IS_TRACEMAINNODE == pDO->GetCookieType() )
                || ( COOKIE_IS_ALERTMAINNODE == pDO->GetCookieType() ) )
        {
            if( CCM_INSERTIONALLOWED_NEW & *pInsertionAllowed ) {
                // Add "New Query..." context menu item
                hr = m_ipCompData->AddMenuItems ( pDataObject, pCallbackUnknown, pInsertionAllowed );
            
            } else if( CCM_INSERTIONALLOWED_TASK & *pInsertionAllowed ) {
                if ( m_ipCompData->IsLogQuery ( pDO->GetCookie() ) ) {
                    pQuery = (CSmLogQuery*)pDO->GetCookie();

                    if ( NULL != pQuery ) {

                        ZeroMemory ( &ctxMenu, sizeof ctxMenu );

                        // Add "Start" context menu item
                        strTemp1.LoadString ( IDS_MMC_MENU_START );
                        strTemp2.LoadString ( IDS_MMC_STATUS_START );
                        ctxMenu[0].strName = T2OLE(const_cast<LPTSTR>((LPCTSTR)strTemp1));
                        ctxMenu[0].strStatusBarText = T2OLE(const_cast<LPTSTR>((LPCTSTR)strTemp2));
                        ctxMenu[0].lCommandID        = IDM_START_QUERY;
                        ctxMenu[0].lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
                        ctxMenu[0].fFlags            = MF_ENABLED;
                        ctxMenu[0].fSpecialFlags     = 0;

                        // Add "Stop" context menu item
                        strTemp3.LoadString ( IDS_MMC_MENU_STOP );
                        strTemp4.LoadString ( IDS_MMC_STATUS_STOP );
                        ctxMenu[1].strName = T2OLE(const_cast<LPTSTR>((LPCTSTR)strTemp3));
                        ctxMenu[1].strStatusBarText = T2OLE(const_cast<LPTSTR>((LPCTSTR)strTemp4));
                        ctxMenu[1].lCommandID        = IDM_STOP_QUERY;
                        ctxMenu[1].lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
                        ctxMenu[1].fFlags            = MF_ENABLED;
                        ctxMenu[1].fSpecialFlags     = 0;

                        // Add "Save As..." context menu item
                        strTemp5.LoadString ( IDS_MMC_MENU_SAVE_AS );
                        strTemp6.LoadString ( IDS_MMC_STATUS_SAVE_AS );
                        ctxMenu[2].strName = T2OLE(const_cast<LPTSTR>((LPCTSTR)strTemp5));
                        ctxMenu[2].strStatusBarText = T2OLE(const_cast<LPTSTR>((LPCTSTR)strTemp6));
                        ctxMenu[2].lCommandID        = IDM_SAVE_QUERY_AS;
                        ctxMenu[2].lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
                        ctxMenu[2].fFlags            = MF_ENABLED;
                        ctxMenu[2].fSpecialFlags     = 0;

                        if ( pQuery->IsRunning() ) {
                            ctxMenu[0].fFlags = MF_GRAYED;
                        } else {
                            ctxMenu[1].fFlags = MF_GRAYED;
                        }

                        hr = pCallbackUnknown->AddItem( &ctxMenu[0] );

                        if ( SUCCEEDED( hr ) ) {
                            hr = pCallbackUnknown->AddItem( &ctxMenu[1] );
                        }
                        if ( SUCCEEDED( hr ) ) {
                            hr = pCallbackUnknown->AddItem( &ctxMenu[2] );
                        }
                    } else {
                        ASSERT ( FALSE );
                        hr = E_UNEXPECTED;
                    }
                }
            } else {
                hr = S_OK;
            }
        }
    }
    
    return hr;
} // end AddMenuItems()

//---------------------------------------------------------------------------
//  Implement the command method so we can handle notifications
//  from our Context menu extensions.
//
STDMETHODIMP
CComponent::Command (
    long nCommandID,                // [in] Command to handle
    LPDATAOBJECT pDataObject )      // [in] Points to data object, pass through
{
    HRESULT hr = S_OK;

    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    ASSERT( NULL != m_ipCompData );  

    switch( nCommandID ) {

    case IDM_NEW_QUERY:
        m_ipCompData->CreateNewLogQuery( pDataObject );
        break;

    case IDM_NEW_QUERY_FROM:
        m_ipCompData->CreateLogQueryFrom( pDataObject );
        break;

    case IDM_START_QUERY:
        StartLogQuery( pDataObject );
        break;

    case IDM_STOP_QUERY:
        StopLogQuery( pDataObject );
        break;

    case IDM_SAVE_QUERY_AS:
        SaveLogQueryAs( pDataObject );
        break;

    default:
        hr = S_FALSE;
    }

    return hr;

} // end Command()

/////////////////////////////////////////////////////////////////////////////
// IExtendControlBar implementation

//---------------------------------------------------------------------------
// Now the toolbar has three buttons
// We don't attach the toolbar to a window yet, that is handled
// after we get a notification.
//
STDMETHODIMP
CComponent::SetControlbar (
    LPCONTROLBAR  pControlbar )  // [in] Points to IControlBar
{
    HRESULT hr = S_OK;
    HBITMAP hbmpToolbarRes = NULL;
    HWND    hwndMain = NULL;

    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    if( NULL != pControlbar ) {           // Make sure the Controlbar is OK

        if( NULL != m_ipControlbar ) {       // Don't orphan it if we already
                                             // had a pointer to it
            m_ipControlbar->Release();
        }

        m_ipControlbar = pControlbar;      // Cache the pointer
        m_ipControlbar->AddRef();

        if( NULL == m_ipToolbarLogger ) {        // Toolbar not created yet...

            hr = m_ipControlbar->Create(
                                    TOOLBAR,
                                    this,
                                    reinterpret_cast<LPUNKNOWN*>(&m_ipToolbarLogger) );
            if ( SUCCEEDED ( hr ) ) {
                hr = m_ipConsole->GetMainWindow( &hwndMain );
            }
            if ( SUCCEEDED ( hr ) ) {

                LoadLogToolbarStrings ( ToolbarResultBtnsLog );
                
                // Add the toolbar bitmap

                // Load special start button bitmap if RTL layout is enabled.
                if ( ! ( CWnd::FromHandle(hwndMain)->GetExStyle() & WS_EX_LAYOUTRTL ) ) {
                    hbmpToolbarRes = LoadBitmap( g_hinst, MAKEINTRESOURCE(IDB_TOOLBAR_RES));
                } else {
                    hbmpToolbarRes = LoadBitmap( g_hinst, MAKEINTRESOURCE(IDB_TOOLBAR_RES_RTL ));
                }
                
                hr = m_ipToolbarLogger->AddBitmap( 3, hbmpToolbarRes, 16, 16, RGB(255,0,255) );
                
                ASSERT( SUCCEEDED(hr) );
                // Add a few buttons
                hr = m_ipToolbarLogger->AddButtons(cResultBtnsLog, ToolbarResultBtnsLog);
            }
        }
        if( NULL == m_ipToolbarAlerts ) {        // Toolbar not created yet...

            hr = m_ipControlbar->Create(
                                    TOOLBAR,
                                    this,
                                    reinterpret_cast<LPUNKNOWN*>(&m_ipToolbarAlerts) );

            if ( SUCCEEDED ( hr ) ) {
                hr = m_ipConsole->GetMainWindow( &hwndMain );
            }

            if ( SUCCEEDED ( hr ) ) {

                LoadAlertToolbarStrings ( ToolbarResultBtnsAlert );

                // Add the toolbar bitmap
                // Load special start button bitmap if RTL layout is enabled.
                if ( ! ( CWnd::FromHandle(hwndMain)->GetExStyle() & WS_EX_LAYOUTRTL ) ) {
                    hbmpToolbarRes = LoadBitmap( g_hinst, MAKEINTRESOURCE(IDB_TOOLBAR_RES));
                } else {
                    hbmpToolbarRes = LoadBitmap( g_hinst, MAKEINTRESOURCE(IDB_TOOLBAR_RES_RTL ));
                }
                hr = m_ipToolbarAlerts->AddBitmap( 3, hbmpToolbarRes, 16, 16, RGB(255,0,255) );
                // Add a few buttons
                hr = m_ipToolbarAlerts->AddButtons(cResultBtnsAlert, ToolbarResultBtnsAlert);
            }
        }

        if( NULL != hbmpToolbarRes ) {
            DeleteObject(hbmpToolbarRes);
        }
        
        // Finished creating the toolbars
        hr = S_OK;
    } else {                    
        hr = S_FALSE;                    // No ControlBar available
    }

    return hr;

} // end SetControlBar()


//---------------------------------------------------------------------------
//  Handle ControlBar notifications to our toolbar
//  Now we can delete an object
//
STDMETHODIMP
CComponent::ControlbarNotify (
    MMC_NOTIFY_TYPE    event,    // [in] Type of notification
    LPARAM             arg,      // [in] Depends on notification
    LPARAM             param )    // [in] Depends on notification
{
    HRESULT hr = S_OK;
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    ASSERT( NULL != m_ipCompData );  

    switch( event ){
        case MMCN_BTN_CLICK:                    // For a Controlbar click, the
            switch( param ) {                   // param is the MenuItemID
                case IDM_NEW_QUERY:
                    m_ipCompData->CreateNewLogQuery( reinterpret_cast<LPDATAOBJECT>(arg) );
                    break;

                case IDM_START_QUERY:
                    StartLogQuery ( reinterpret_cast<LPDATAOBJECT>(arg) );
                    break;

                case IDM_STOP_QUERY:
                    StopLogQuery ( reinterpret_cast<LPDATAOBJECT>(arg) );
                    break;

                default:
                    LOCALTRACE( _T("ControlbarNotify: Unknown message") );
                }
            break;

        case MMCN_DESELECT_ALL:            // How to display the Toolbar
        case MMCN_SELECT:
            hr = HandleExtToolbars( (event == MMCN_DESELECT_ALL), arg, param );
            break;

        case MMCN_MENU_BTNCLICK:           // Not handling menus here
              DebugMsg( _T("MMCN_MENU_BTNCLICK"), _T("CComponent::ControlbarNotify") );
              // Drop through...
        default:
              hr = S_FALSE;
              break;
    }

    return hr;

} // end ControlbarNotify()

//---------------------------------------------------------------------------
//  Handle how the toolbars are displayed
//
HRESULT
CComponent::HandleExtToolbars (
    bool    bDeselectAll,       // [in] Notification
    LPARAM     /* arg */,       // [in] Depends on notification
    LPARAM  param               // [in] Depends on notification
    )          
{
    HRESULT hr = S_OK;
    BOOL bStartEnable = FALSE;
    BOOL bStopEnable = FALSE;
    BOOL bNewEnable = FALSE;
    CDataObject* pDO = NULL;
    LPDATAOBJECT pDataObject;
    CSmLogQuery* pQuery = NULL;
    
    ASSERT( NULL != m_ipCompData );  

    pDataObject = reinterpret_cast<LPDATAOBJECT>(param);

    if( NULL == pDataObject ) {
        hr = S_FALSE;
    } else {
        pDO = ExtractOwnDataObject( pDataObject );
        if ( NULL == pDO ) {
            hr = E_UNEXPECTED;
        }

        if ( SUCCEEDED ( hr ) ) {
            hr = S_FALSE;
            if( CCT_SCOPE == pDO->GetContext() ) {
                // Scope item selected, in either the scope or result pane.
                if( COOKIE_IS_ROOTNODE == pDO->GetCookieType() ) {
                    if ( NULL != m_ipToolbarAttached ) {
                        hr = m_ipControlbar->Detach( (LPUNKNOWN)m_ipToolbarAttached );
                        m_ipToolbarAttached = NULL;
                    }
                    ASSERT( SUCCEEDED(hr) );
                } else if( COOKIE_IS_ALERTMAINNODE == pDO->GetCookieType() ) {
                    // Attach the Alerts toolbar
                    if ( m_ipToolbarAttached != NULL && m_ipToolbarAttached != m_ipToolbarAlerts ) {
                        hr = m_ipControlbar->Detach( (LPUNKNOWN)m_ipToolbarAttached );
                        m_ipToolbarAttached = NULL;
                    }

                    hr = m_ipControlbar->Attach(TOOLBAR, (LPUNKNOWN)m_ipToolbarAlerts);
                    ASSERT( SUCCEEDED(hr) );
                    m_ipToolbarAttached = m_ipToolbarAlerts;

                    bNewEnable = TRUE;
                } else {
                    // Attach the Logger toolbar
                    if ( m_ipToolbarAttached != NULL && m_ipToolbarAttached != m_ipToolbarLogger ) {
                        hr = m_ipControlbar->Detach( (LPUNKNOWN)m_ipToolbarAttached );
                        m_ipToolbarAttached = NULL;
                    }

                    hr = m_ipControlbar->Attach(TOOLBAR, (LPUNKNOWN)m_ipToolbarLogger);
                    ASSERT( SUCCEEDED(hr) );
                    m_ipToolbarAttached = m_ipToolbarLogger;

                    bNewEnable = TRUE;
                }
            } else {

                if ( !bDeselectAll ) {

                    // Result pane context.
                    if( CCT_RESULT == pDO->GetContext() ) {
                        bStartEnable = m_ipCompData->IsLogQuery (pDO->GetCookie()) ? TRUE : FALSE;
                        if (bStartEnable) {
                            // then this is a log query, so see if the item is running or not
                            pQuery = (CSmLogQuery*)pDO->GetCookie();
                            if ( NULL != pQuery ) {
                                if (pQuery->IsRunning()) {
                                    // enable only the stop button
                                    bStartEnable = FALSE;
                                } else {
                                    // enable only the start button
                                }
                            } else {
                                ASSERT ( FALSE );
                            }
                            bStopEnable = !bStartEnable;
                        }
                    }
                } else {
                    bNewEnable = TRUE;
                }
            }

            if ( NULL != m_ipToolbarAttached ) {
                hr = m_ipToolbarAttached->SetButtonState( IDM_NEW_QUERY, ENABLED , bNewEnable );
                ASSERT( SUCCEEDED(hr) );

                hr = m_ipToolbarAttached->SetButtonState( IDM_START_QUERY, ENABLED , bStartEnable );
                ASSERT( SUCCEEDED(hr) );

                hr = m_ipToolbarAttached->SetButtonState( IDM_STOP_QUERY, ENABLED , bStopEnable );
                ASSERT( SUCCEEDED(hr) );
            }
        }
    }
    return hr;

} // end HandleExtToolbars()


/////////////////////////////////////////////////////////////////////////////
// IExtendPropertySheet implementation
//

HRESULT 
CComponent::AddPropertyPage ( 
    LPPROPERTYSHEETCALLBACK lpProvider, 
    CSmPropertyPage*& rpPage 
    )
{
    HRESULT hr = S_OK;
    PROPSHEETPAGE_V3 sp_v3 = {0};
    HPROPSHEETPAGE   hPage = NULL;

    ASSERT( NULL != m_ipCompData );  

    if ( NULL == rpPage ) {
        ASSERT ( FALSE );
        hr = E_UNEXPECTED;
    } else {

        rpPage->SetContextHelpFilePath( m_ipCompData->GetContextHelpFilePath() );
    
        rpPage->m_psp.lParam = (INT_PTR)rpPage;
        rpPage->m_psp.pfnCallback = &CSmPropertyPage::PropSheetPageProc;

        CopyMemory (&sp_v3, &rpPage->m_psp, rpPage->m_psp.dwSize);
        sp_v3.dwSize = sizeof(sp_v3);

        hPage = CreatePropertySheetPage (&sp_v3);

        if ( NULL != hPage ) {
            hr = lpProvider->AddPage(hPage);
            if ( FAILED(hr) ) {
                ASSERT ( FALSE );
                delete rpPage;
                rpPage = NULL;
            }
        } else {
            delete rpPage;
            rpPage = NULL;
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        }
    }
    return hr;

}


HRESULT
CComponent::CreatePropertyPages(
    LPPROPERTYSHEETCALLBACK lpProvider,    // Pointer to the callback interface
    LONG_PTR                handle,        // Handle for routing notification
    LPDATAOBJECT            pDataObject    // Pointer to the data object
    )
{
    HRESULT         hr = S_OK;
    CDataObject*    pDO = NULL;
    MMC_COOKIE      Cookie;
    CSmLogQuery*    pQuery = NULL;
    DWORD           dwLogType;

    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    ASSERT( NULL != m_ipCompData );  

    if ( NULL == pDataObject 
                || NULL == lpProvider ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        pDO = ExtractOwnDataObject(pDataObject);
        if ( NULL == pDO ) {
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        }
    }

    //         We cheat a little here and pass what we need to a custom
    //         constructor for our derived property page class

    if ( SUCCEEDED ( hr ) ) {
        Cookie = pDO->GetCookie();
        if ( NULL != Cookie ) {
            CWnd* pPropSheet = NULL;
            
            pQuery = (CSmLogQuery *)Cookie;

            if ( NULL != pQuery ) {
                // If the property sheet for this query is already active, just bring it to the foreground.

                pPropSheet = pQuery->GetActivePropertySheet();

                if ( NULL != pPropSheet ) {

                    pPropSheet->SetForegroundWindow();
                    MMCFreeNotifyHandle(handle);
                    hr = S_FALSE;
            
                } else {

                    dwLogType = pQuery->GetLogType();

                    if (SLQ_ALERT != dwLogType) { 
        
                        if ( SLQ_TRACE_LOG == dwLogType) {
                            CSmPropertyPage*    pPage1 = NULL;  
                            CWaitCursor         WaitCursor;
                    
                            // Connect to the server before creating the dialog 
                            // so that the wait cursor can be used consistently.

                            // Sync the providers here so that the WMI calls are consistently
                            // from a single thread.
                            ASSERT ( NULL != pQuery->CastToTraceLogQuery() );
                            hr = (pQuery->CastToTraceLogQuery())->SyncGenProviders();

                            if ( SUCCEEDED ( hr ) ) {
                                MFC_TRY
                                    pPage1 = new CProvidersProperty (Cookie, handle);
                                    if ( NULL != pPage1 ) {
                                        hr = AddPropertyPage ( lpProvider, pPage1 );
                                    }
                                MFC_CATCH_HR
                            } else {
                                CString strMachineName;
                                CString strLogName;

                                pQuery->GetMachineDisplayName( strMachineName );
                                strLogName = pQuery->GetLogName();
                        
                                m_ipCompData->HandleTraceConnectError ( 
                                    hr, 
                                    strLogName,
                                    strMachineName );
                            }

                        } else {
                            CSmPropertyPage *pPage1 = NULL;

                            MFC_TRY
                                pPage1 = new CCountersProperty (Cookie, handle );
                                if ( NULL != pPage1 ) {
                                    hr = AddPropertyPage ( lpProvider, pPage1 );
                                } 
                            MFC_CATCH_HR
                        }

                        if ( SUCCEEDED(hr) ) {
                            CSmPropertyPage* pPage2 = NULL;
                            CSmPropertyPage* pPage3 = NULL;
        
                            MFC_TRY
                                pPage2 = new CFilesProperty(Cookie, handle);
                                if ( NULL != pPage2 ) {
                                    hr = AddPropertyPage ( lpProvider, pPage2 );
                                } 

                                if ( SUCCEEDED(hr) ) {
                                    pPage3 = new CScheduleProperty (Cookie, handle, pDataObject );
                                    if ( NULL != pPage3 ) {
                                        hr = AddPropertyPage ( lpProvider, pPage3 );
                                    } 
                                }
                            MFC_CATCH_HR

                            if ( FAILED(hr) ) {
                                if ( NULL != pPage3 ) {
                                    delete pPage3;
                                }
                                if ( NULL != pPage2 ) {
                                    delete pPage2;
                                }
                            }
                        }

                        if ( SUCCEEDED(hr) ) {

                            if ( SLQ_TRACE_LOG == pQuery->GetLogType() ) {
                                CSmPropertyPage*    pPage4 = NULL;
                        
                                MFC_TRY
                                    pPage4 = new CTraceProperty(Cookie, handle);
                                    if ( NULL != pPage4 ) {
                                        hr = AddPropertyPage ( lpProvider, pPage4 );
                                    } 
                                MFC_CATCH_HR
                            }
                        }
                    } else {
                        ASSERT ( SLQ_ALERT == dwLogType );

                        CSmPropertyPage*    pPage1 = NULL;
                        CSmPropertyPage*    pPage2 = NULL;
                        CSmPropertyPage*    pPage3 = NULL;
        
                        MFC_TRY
                            pPage1 = new CAlertGenProp (Cookie, handle);
                            if ( NULL != pPage1 ) {
                                hr = AddPropertyPage ( lpProvider, pPage1 );
                            } 

                            if ( SUCCEEDED(hr) ) {
                                pPage2 = new CAlertActionProp (Cookie, handle);
                                if ( NULL != pPage2 ) {
                                    hr = AddPropertyPage ( lpProvider, pPage2 );
                                } 
                            }

                            if ( SUCCEEDED(hr) ) {
                                pPage3 = new CScheduleProperty (Cookie, handle, pDataObject);
                                if ( NULL != pPage3 ) {
                                    hr = AddPropertyPage ( lpProvider, pPage3 );
                                } 
                            }
                        MFC_CATCH_HR

                        if ( FAILED(hr) ) {
                            if ( NULL != pPage3 ) {
                                delete pPage3;
                            }
                            if ( NULL != pPage2 ) {
                                delete pPage2;
                            }
                            if ( NULL != pPage1 ) {
                                delete pPage1;
                            }
                        }
                    }
                }
            } else {
                ASSERT ( FALSE );
                hr = E_UNEXPECTED;
            }
        } else {
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        }
    }
    return hr;

} // end CreatePropertyPages()


//---------------------------------------------------------------------------
// The console calls this method to determine whether the Properties menu
// item should be added to the context menu.  We added the Properties item
// by enabling the verb.  So long as we have a vaild DataObject we
// can return OK.
//
HRESULT
CComponent::QueryPagesFor (
    LPDATAOBJECT pDataObject ) // [in] Points to IDataObject for selected node
{
    HRESULT hr = S_OK;
    CDataObject* pDO = NULL;

    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    if ( NULL == pDataObject ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        pDO = ExtractOwnDataObject(pDataObject);
        if ( NULL == pDO ) {
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        }
    }

    if ( SUCCEEDED ( hr ) ) {
        if ( COOKIE_IS_COUNTERMAINNODE == pDO->GetCookieType()
                || COOKIE_IS_TRACEMAINNODE == pDO->GetCookieType()
                || COOKIE_IS_ALERTMAINNODE == pDO->GetCookieType() )
        {
            hr = S_OK;
        } else {
            hr = S_FALSE;
        }
    }
    return hr;

} // end QueryPagesFor()

HRESULT
CComponent::PopulateResultPane (
    MMC_COOKIE  mmcCookie )
{
    HRESULT     hr = S_OK;
    PSLSVC      pSLSVC = NULL;
    PSLQUERY    pSlQuery = NULL;
    POSITION    Pos;
    RESULTDATAITEM rdi;

    ASSERT ( NULL != m_ipResultData );

    if ( NULL == mmcCookie ) {
        ASSERT ( FALSE );
        hr = E_INVALIDARG;
    } else {
        pSLSVC = reinterpret_cast<PSLSVC>(mmcCookie);       
        ASSERT ( NULL != pSLSVC->CastToLogService() ); 

        hr = m_ipResultData->DeleteAllRsltItems();

        if( SUCCEEDED(hr) ) {

            memset(&rdi, 0, sizeof(RESULTDATAITEM));
            rdi.mask =   RDI_STR     |         // Displayname is valid
                         // RDI_IMAGE   |         // nImage is valid
                         RDI_PARAM;            // lParam is valid

            rdi.str    = MMC_CALLBACK;
            rdi.nImage = 2;

            Pos = pSLSVC->m_QueryList.GetHeadPosition();

            // load the query object pointers into the results page
            while ( Pos != NULL) {
                pSlQuery = pSLSVC->m_QueryList.GetNext( Pos );
                rdi.lParam = reinterpret_cast<LPARAM>(pSlQuery);
                hr = m_ipResultData->InsertItem( &rdi );
                if( FAILED(hr) )
                    DisplayError( hr, _T("PopulateResultPane") );
            }
        }
    }

    return hr;
} // end PopulateResultPane()

HRESULT
CComponent::RefreshResultPane (
    MMC_COOKIE mmcCookie )
{
    HRESULT hr = S_OK;
    DWORD dwStatus = ERROR_SUCCESS;
    PSLSVC    pSLSVC = reinterpret_cast<PSLSVC>(mmcCookie);

    ASSERT( NULL != m_ipResultData );    
    
    // Cookie is null if refresh is activated when right pane is not
    // populated with queries.
    if ( NULL != pSLSVC ) {

        dwStatus = pSLSVC->SyncWithRegistry();

        // Todo:  Server Beta 3 - display error message if any property pages are open. 

        if ( ERROR_SUCCESS == dwStatus ) {
            hr = PopulateResultPane( mmcCookie );
        } else {
            hr = E_FAIL;
        }
    }
    return hr;
}

HRESULT
CComponent::OnDelete (
    LPDATAOBJECT pDataObject,      // [in] Points to data object
    LPARAM     /* arg */   ,       // Not used     
    LPARAM     /* param */         // Not used
    )
{
    HRESULT     hr = S_OK;
    DWORD       dwStatus = ERROR_SUCCESS;
    CDataObject *pDO = NULL;
    PSLQUERY    pQuery = NULL;
    CSmLogService* pSvc = NULL;
    int         iResult;
    CString     strMessage;
    CString     csTitle;
    CString     strMachineName;
    MMC_COOKIE  mmcCookie = 0;
    BOOL        bIsQuery = FALSE;
    BOOL        bContinue = TRUE;
    ResourceStateManager    rsm;
    HRESULTITEM hItemID = NULL;
    RESULTDATAITEM  rdi;

    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    ASSERT( NULL != m_ipCompData );  

    if ( NULL == pDataObject ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        pDO = ExtractOwnDataObject( pDataObject );

        if( NULL == pDO ) {
            // Unknown data object
            strMessage.LoadString ( IDS_ERRMSG_UNKDATAOBJ );
            hr = m_ipConsole->MessageBox( (LPCWSTR)strMessage,
                _T("CComponentData::OnDelete"),
                MB_OK | MB_ICONERROR,
                &iResult
                );
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        } else {
            // If this is the root node, don't need to do anything
            if( COOKIE_IS_ROOTNODE == pDO->GetCookieType() ) {
                hr = S_FALSE;
            } else {
                // Just make sure we are where we think we are
                ASSERT( CCT_RESULT == pDO->GetContext() );
                ASSERT( COOKIE_IS_COUNTERMAINNODE == pDO->GetCookieType()
                        || COOKIE_IS_TRACEMAINNODE == pDO->GetCookieType()
                        || COOKIE_IS_ALERTMAINNODE == pDO->GetCookieType() );

                mmcCookie = (MMC_COOKIE)pDO->GetCookie();

                bIsQuery = m_ipCompData->IsLogQuery (mmcCookie);

                if (bIsQuery) {
                    pQuery = (PSLQUERY)mmcCookie;

                    if ( NULL != pQuery ) {
                        pSvc = ( pQuery->GetLogService() );
                        if ( !pQuery->IsExecuteOnly() ) {
                            if ( pQuery->IsModifiable() ) {
                                if ( m_ipCompData->IsRunningQuery( pQuery ) ) {
                                    iResult = IDOK;

                                    // Don't delete running queries.  Stop the query if requested
                                    // by the user.
                                    strMessage.LoadString ( IDS_ERRMSG_DELETE_RUNNING_QUERY );
                                    csTitle.LoadString ( IDS_PROJNAME );
                                    hr = m_ipConsole->MessageBox(
                                            (LPCWSTR)strMessage,
                                            (LPCWSTR)csTitle,
                                            MB_OKCANCEL | MB_ICONWARNING,
                                            &iResult
                                            );

                                    if ( IDOK == iResult ) {
                                        // If property page is open, StopLogQuery 
                                        // shows error message
                                        hr = StopLogQuery ( pDataObject, FALSE );
                                        if ( FAILED ( hr ) ) {
                                            bContinue = TRUE;
                                            hr = S_FALSE;
                                        }
                                    } else {
                                        bContinue = FALSE;
                                        hr = S_FALSE;
                                    }
                                } else if ( NULL != pQuery->GetActivePropertySheet() ){
                                    // Don't delete queries with open property pages.
                                    strMessage.LoadString ( IDS_ERRMSG_DELETE_OPEN_QUERY );
                                    csTitle.LoadString ( IDS_PROJNAME );
                                    hr = m_ipConsole->MessageBox(
                                            (LPCWSTR)strMessage,
                                            (LPCWSTR)csTitle,
                                            MB_OK | MB_ICONWARNING,
                                            &iResult );
                        
                                    ((CWnd*)pQuery->GetActivePropertySheet())->SetForegroundWindow();

                                    bContinue = FALSE;
                                    hr = S_FALSE;

                                } 
                                            
                                if ( bContinue ) {
                                    if ( NULL != pSvc ) {
                                        hr = m_ipResultData->FindItemByLParam ( (LPARAM)mmcCookie, &hItemID );
                                        if ( SUCCEEDED(hr) ) {

                                            hr = m_ipResultData->DeleteItem ( hItemID, 0 );

                                            if ( SUCCEEDED(hr) ) {

                                                dwStatus = pSvc->DeleteQuery(pQuery);

                                                // Mark as deleted, because already deleted 
                                                // from the UI.  
                                                hr = S_OK;
                                            } else {
                                                hr = S_FALSE;
                                            }
                                        }
                                    } else {
                                        ASSERT ( FALSE );
                                        hr = E_UNEXPECTED;
                                    }
                                }
                            } else {
                                if ( NULL != pSvc ) {
                                    strMachineName = pSvc->GetMachineDisplayName();
                                } else {
                                    strMachineName.Empty();
                                }

                                FormatSmLogCfgMessage (
                                    strMessage,
                                    m_hModule,
                                    SMCFG_NO_MODIFY_ACCESS,
                                    (LPCTSTR)strMachineName);

                                csTitle.LoadString ( IDS_PROJNAME );
                                hr = m_ipConsole->MessageBox(
                                                    (LPCWSTR)strMessage,
                                                    (LPCWSTR)csTitle,
                                                    MB_OK | MB_ICONERROR,
                                                    &iResult );
                                hr = S_FALSE; 
                            }
                        } else {

                            // Don't delete template queries.
                            strMessage.LoadString ( IDS_ERRMSG_DELETE_TEMPLATE_QRY );
                            csTitle.LoadString ( IDS_PROJNAME );
                            hr = m_ipConsole->MessageBox(
                                    (LPCWSTR)strMessage,
                                    (LPCWSTR)csTitle,
                                    MB_OK | MB_ICONERROR,
                                    &iResult
                                    );
                            hr = S_FALSE;
                        }
                    } else {
                        ASSERT ( FALSE );
                        hr = E_UNEXPECTED;
                    }
                } else {
                    hr = S_FALSE;
                }
            }
        }
    }

    return hr;
}

HRESULT
CComponent::OnDoubleClick (
    ULONG ulRecNo,
    LPDATAOBJECT pDataObject )  // [in] Points to the data object
{
    HRESULT     hr = S_OK;
    CDataObject* pDO = NULL;
    MMC_COOKIE  mmcCookie;
    BOOL bIsQuery = FALSE;
    PSLQUERY    pQuery = NULL;
    LONG_PTR    handle = NULL;
    CWnd*       pPropSheet = NULL;

    ASSERT( NULL != m_ipResultData );
    ASSERT( NULL != m_ipCompData );  

    if ( NULL == pDataObject ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        pDO = ExtractOwnDataObject(pDataObject);
        if ( NULL == pDO ) {
            hr = S_OK;
        } else {

            // If this is the root node, don't need to do anything
            if( COOKIE_IS_ROOTNODE == pDO->GetCookieType() ) {
                hr = S_FALSE;
            } else if ( CCT_RESULT != pDO->GetContext() ) {
                // Just make sure we are where we think we are
                hr = S_FALSE;
            }

            if ( S_OK == hr ) {
                mmcCookie = (MMC_COOKIE)pDO->GetCookie();
                bIsQuery = m_ipCompData->IsLogQuery (mmcCookie);

                if (!bIsQuery) {
                    // Pass the notification to the scope pane to expand.
                    hr = S_FALSE;
                } else {
                    pQuery = (PSLQUERY)mmcCookie;
 
                    if ( NULL != pQuery ) {
                        // If the property sheet for this query is already active, just bring it to the foreground.                
                        pPropSheet = pQuery->GetActivePropertySheet();

                        if ( NULL != pPropSheet ) {

                            pPropSheet->SetForegroundWindow();
                            MMCFreeNotifyHandle(handle);
                            hr = S_OK;
            
                        } else {
                            hr = _InvokePropertySheet(ulRecNo, pDataObject);
                        }
                    } else {
                        ASSERT ( FALSE );
                        hr = E_UNEXPECTED;
                    }
                }
            }
        }
    }

    return hr;

} // end OnDoubleClick()


HRESULT
CComponent::StartLogQuery (
    LPDATAOBJECT pDataObject ) // [in] Points to the data object
{
    HRESULT                 hr = S_OK;
    CDataObject*            pDO = NULL;
    CSmLogQuery*            pQuery = NULL;
    CString                 strMessage;
    CString                 strSysMessage;
    CString                 strTitle;
    CString                 strMachineName;
    int                     iResult;
    DWORD                   dwStatus = ERROR_SUCCESS;
    ResourceStateManager    rsm;

    ASSERT( NULL != m_ipCompData );  

    if ( NULL == pDataObject ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        pDO = ExtractOwnDataObject(pDataObject);
        if ( NULL == pDO ) {
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        }
    }

    if ( SUCCEEDED ( hr ) ) {
        if ( m_ipCompData->IsLogQuery ( pDO->GetCookie() ) ) {
                
            pQuery = (CSmLogQuery*)pDO->GetCookie();

            if ( NULL != pQuery ) {

                if ( NULL != pQuery->GetActivePropertySheet() ) {

                    // Don't start queries with open property pages.
                    strMessage.LoadString ( IDS_ERRMSG_START_OPEN_QUERY );
                    hr = m_ipConsole->MessageBox(
                            (LPCWSTR)strMessage,
                            pQuery->GetLogName(),
                            MB_OK | MB_ICONWARNING,
                            &iResult );
            
                    ((CWnd*)pQuery->GetActivePropertySheet())->SetForegroundWindow();

                    hr = S_FALSE;

                } else {        

                    {
                        CWaitCursor WaitCursor;
                        dwStatus = pQuery->ManualStart();
                    }
            
                    // Ignore errors related to autostart setting.
                    if ( ERROR_SUCCESS == dwStatus  ) {
                        // Update all views generates view change notification.
                        m_ipConsole->UpdateAllViews (pDO, 0, CComponentData::eSmHintStartQuery );
                    } else {

                        strTitle.LoadString ( IDS_PROJNAME );

                        if ( ERROR_ACCESS_DENIED == dwStatus ) {

                            pQuery->GetMachineDisplayName ( strMachineName );

                            FormatSmLogCfgMessage (
                                strMessage,
                                m_hModule,
                                SMCFG_NO_MODIFY_ACCESS,
                                (LPCTSTR)strMachineName);

                        } else if ( SMCFG_START_TIMED_OUT == dwStatus ) {
                            FormatSmLogCfgMessage (
                                strMessage,
                                m_hModule,
                                SMCFG_START_TIMED_OUT,
                                (LPCTSTR)pQuery->GetLogName());

                        } else {
                    
                            FormatSmLogCfgMessage (
                                strMessage,
                                m_hModule,
                                SMCFG_SYSTEM_MESSAGE,
                                (LPCTSTR)pQuery->GetLogName());

                            FormatMessage ( 
                                FORMAT_MESSAGE_FROM_SYSTEM,
                                NULL, 
                                dwStatus,
                                0,
                                strSysMessage.GetBufferSetLength( MAX_PATH ),
                                MAX_PATH,
                                NULL );
    
                            strSysMessage.ReleaseBuffer();

                            if ( strSysMessage.IsEmpty() ) {
                                strSysMessage.Format ( _T("0x%08lX"), dwStatus );   
                            }

                            strMessage += strSysMessage;
                        }

                        hr = m_ipConsole->MessageBox(
                            strMessage,
                            strTitle,
                            MB_OK | MB_ICONERROR,
                            &iResult );

                        hr = E_FAIL;
                    }
                }
            } else {
                ASSERT ( FALSE );
                hr = E_UNEXPECTED;
            }
        }
    }
    return hr;
} // end StartLogQuery()

HRESULT
CComponent::StopLogQuery (
    LPDATAOBJECT pDataObject,  // [in] Points to the data object
    BOOL bWarnOnRestartCancel )  
{
        HRESULT         hr = S_OK;
        CDataObject*    pDO = NULL;
        CSmLogQuery*    pQuery = NULL;
        DWORD           dwStatus = ERROR_SUCCESS;
        INT             iResult = IDOK;
        CString         strMessage;
        CString         strSysMessage;
        CString         strTitle;
        CString         strMachineName;
        ResourceStateManager    rsm;
 
    ASSERT( NULL != m_ipCompData );  

    if ( NULL == pDataObject ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        pDO = ExtractOwnDataObject(pDataObject);
        if ( NULL == pDO ) {
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        }
    }

    if ( SUCCEEDED ( hr ) ) {
        if ( m_ipCompData->IsLogQuery ( pDO->GetCookie() ) ) {
            pQuery = (CSmLogQuery*)pDO->GetCookie();

            if ( NULL != pQuery ) {
                if ( NULL != pQuery->GetActivePropertySheet() ) {

                    // Don't stop queries with open property pages.
                    strMessage.LoadString ( IDS_ERRMSG_STOP_OPEN_QUERY );
                    hr = m_ipConsole->MessageBox(
                            (LPCWSTR)strMessage,
                            pQuery->GetLogName(),
                            MB_OK | MB_ICONWARNING,
                            &iResult );
            
                    ((CWnd*)pQuery->GetActivePropertySheet())->SetForegroundWindow();

                    hr = S_FALSE;

                } else {

                    if ( pQuery->IsAutoRestart() && bWarnOnRestartCancel ) {
                        CString strMessage;

                        strMessage.LoadString( IDS_CANCEL_AUTO_RESTART );

                        hr = m_ipConsole->MessageBox(
                            strMessage,
                            pQuery->GetLogName(),
                            MB_OKCANCEL | MB_ICONINFORMATION,
                            &iResult );
                    }

                    if ( IDOK == iResult ) {
                        {
                            CWaitCursor WaitCursor;
                            dwStatus = pQuery->ManualStop ();
                        }
    
                        // Ignore errors related to autostart setting.
                        if ( ERROR_SUCCESS == dwStatus  ) {
                            // Update all views generates view change notification.
                            m_ipConsole->UpdateAllViews (pDO, 0, CComponentData::eSmHintStopQuery );
                        } else {
                            strTitle.LoadString ( IDS_PROJNAME );

                            if ( ERROR_ACCESS_DENIED == dwStatus ) {

                                pQuery->GetMachineDisplayName ( strMachineName );

                                FormatSmLogCfgMessage (
                                    strMessage,
                                    m_hModule,
                                    SMCFG_NO_MODIFY_ACCESS,
                                    (LPCTSTR)strMachineName);

                            } else if ( SMCFG_STOP_TIMED_OUT == dwStatus ) {
                                FormatSmLogCfgMessage (
                                    strMessage,
                                    m_hModule,
                                    SMCFG_STOP_TIMED_OUT,
                                    (LPCTSTR)pQuery->GetLogName());

                            } else {
                    
                                FormatSmLogCfgMessage (
                                    strMessage,
                                    m_hModule,
                                    SMCFG_SYSTEM_MESSAGE,
                                    (LPCTSTR)pQuery->GetLogName());

                                FormatMessage ( 
                                    FORMAT_MESSAGE_FROM_SYSTEM,
                                    NULL, 
                                    dwStatus,
                                    0,
                                    strSysMessage.GetBufferSetLength( MAX_PATH ),
                                    MAX_PATH,
                                    NULL );

                                strSysMessage.ReleaseBuffer();

                                if ( strSysMessage.IsEmpty() ) {
                                    strSysMessage.Format ( _T("0x%08lX"), dwStatus );   
                                }

                                strMessage += strSysMessage;
                            } 

                            hr = m_ipConsole->MessageBox(
                                strMessage,
                                strTitle,
                                MB_OK | MB_ICONERROR,
                                &iResult );

                            hr = E_FAIL;
                        }
                    }
                }
            } else {
                ASSERT ( FALSE );
                hr = E_UNEXPECTED;
            }
        }
    }
    return hr;
} // end StopLogQuery()

HRESULT
CComponent::SaveLogQueryAs (
    LPDATAOBJECT pDataObject )  // [in] Points to the data object
{
    HRESULT hr = S_OK;
    DWORD   dwStatus = ERROR_SUCCESS;
    CDataObject* pDO = NULL;
    CSmLogQuery* pQuery = NULL;
    CString strFileExtension;
    CString strFileFilter;
    TCHAR   szDefaultFileName[MAX_PATH];

    INT_PTR iPtrResult = IDCANCEL;
    HWND    hwndMain;
    TCHAR   szInitialDir[MAX_PATH];
    ResourceStateManager    rsm;

    ASSERT( NULL != m_ipCompData );  

    if ( NULL == pDataObject ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        pDO = ExtractOwnDataObject(pDataObject);
        if ( NULL == pDO ) {
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        }
    }

    if ( SUCCEEDED ( hr ) ) {
        if ( m_ipCompData->IsLogQuery ( pDO->GetCookie() ) ) {

            pQuery = (CSmLogQuery*)pDO->GetCookie();

            if ( NULL != pQuery ) {

                MFC_TRY
                    strFileExtension.LoadString ( IDS_HTML_EXTENSION );
                    strFileFilter.LoadString ( IDS_HTML_FILE );
                MFC_CATCH_HR

                strFileFilter.Replace ( _T('|'), _T('\0') );

                lstrcpyW ( ( LPWSTR)szDefaultFileName, pQuery->GetLogName() );

                ReplaceBlanksWithUnderscores( szDefaultFileName );

                hr = m_ipConsole->GetMainWindow( &hwndMain );

                if ( SUCCEEDED(hr) ) {
                    
                    OPENFILENAME ofn;
                    BOOL bResult;
                    
                    ZeroMemory( &ofn, sizeof( OPENFILENAME ) );

                    ofn.lStructSize = sizeof(OPENFILENAME);
                    ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
                    ofn.lpstrDefExt = (LPCTSTR)strFileExtension;
                    ofn.lpstrFile = szDefaultFileName;
                    ofn.lpstrFilter = strFileFilter;
                    ofn.nMaxFile = MAX_PATH;
                    ofn.hwndOwner = hwndMain;
                    ofn.hInstance = m_hModule;

                    if ( SUCCEEDED ( SHGetFolderPathW ( NULL, CSIDL_PERSONAL, NULL, 0, szInitialDir ) ) ) {
                        ofn.lpstrInitialDir = szInitialDir;
                    }

                    bResult = GetSaveFileName( &ofn );

                    if ( bResult ) {

                        dwStatus = pQuery->SaveAs( ofn.lpstrFile );

                        if ( ERROR_SUCCESS != dwStatus ) {
                            hr = E_FAIL;
                        }
                    }
                }
            } else {
                ASSERT ( FALSE );
                hr = E_UNEXPECTED;
            }
        }
    }
    return hr;
} // end SaveLogQueryAs()

//+--------------------------------------------------------------------------
//
//  Member:     CComponent::_InvokePropertySheet
//
//  Synopsis:   Open or bring to foreground an event record details
//              property sheet focused on record [ulRecNo].
//
//  Arguments:  [ulRecNo]     - number of rec to display in prop sheet
//              [pDataObject] - data object containing rec [ulRecNo]
//
//  Returns:    HRESULT
//
//  History:    5-28-1999   a-akamal
//
//---------------------------------------------------------------------------

HRESULT
CComponent::_InvokePropertySheet(
    ULONG ulRecNo,
    LPDATAOBJECT pDataObject)
{
    //TRACE_METHOD(CComponent, _InvokePropertySheet);
    HRESULT     hr = S_OK;
    MMC_COOKIE  Cookie;
    PSLQUERY    pQuery = NULL;
    WCHAR       wszDetailsCaption[MAX_PATH];
    CDataObject* pDO = NULL;

    ASSERT( NULL != m_ipCompData );  
       
    if ( NULL == pDataObject ) {
        ASSERT ( FALSE );
        hr = E_POINTER;
    } else {
        pDO = ExtractOwnDataObject(pDataObject);
        if ( NULL == pDO ) {
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        }
    }

    if ( SUCCEEDED ( hr ) ) {
        
        Cookie = (MMC_COOKIE)pDO->GetCookie();;
        pQuery = (PSLQUERY)Cookie;
    
        if ( NULL != pQuery ) {
            wsprintf(wszDetailsCaption,pQuery->GetLogName());

            hr = InvokePropertySheet (
                    m_ipCompData->GetPropSheetProvider(),
                    wszDetailsCaption,
                    (LONG) ulRecNo,
                    pDataObject,
                    (IExtendPropertySheet*) this,
                    0 );
        } else {
            ASSERT ( FALSE );
            hr = E_UNEXPECTED;
        }
    }
    return hr;
}

//+--------------------------------------------------------------------------
//
//  Function:   InvokePropertySheet
//
//  Synopsis:   Bring to top an existing or create a new property sheet
//              using the parameters provided.
//
//  Arguments:  [pPrshtProvider] - used to search for or create sheet
//              [wszTitle]       - sheet caption
//              [lCookie]        - a loginfo* or an event record number
//              [pDataObject]    - DO on object sheet's being opened on
//                                  (cookie in DO should == cookie)
//              [pPrimary]       - IExtendPropertySheet interface on
//                                  calling CSnapin or CComponentData
//              [usStartingPage] - which page number should be active when
//                                  sheet opens
//
//  Returns:    HRESULT
//
//  History:    5-28-1999   a-akamal
//
//  Notes:      Call this routine when you want a property sheet to appear
//              as if the user had just selected "Properties" on it.
//
//---------------------------------------------------------------------------

HRESULT
CComponent::
InvokePropertySheet(
    IPropertySheetProvider *pPrshtProvider,
    LPCWSTR wszTitle,
    LONG lCookie,
    LPDATAOBJECT pDataObject,
    IExtendPropertySheet *pPrimary,
    USHORT usStartingPage)
{
    HRESULT hr = S_OK;

    //
    // Because we pass NULL for the second arg, the first is not allowed
    // to be null.
    //
    if ( 0 == lCookie ) {
        ASSERT ( FALSE );
        hr = E_INVALIDARG;
    } else {

        do {
            hr = pPrshtProvider->FindPropertySheet(lCookie, NULL, pDataObject);
        
            if ( S_OK == hr ) {
                break;
            }
        
            hr = pPrshtProvider->CreatePropertySheet(wszTitle,
                                                      TRUE,
                                                      lCookie,
                                                      pDataObject,
                                                      0);
            if ( S_OK != hr ) {
                break;
            }
        
            hr = pPrshtProvider->AddPrimaryPages(pPrimary, TRUE, NULL, FALSE);

            if ( S_OK != hr ) {
                break;
            }
        
            hr = pPrshtProvider->Show(NULL, usStartingPage);
        
        } while (0);
    }
    return hr;
}