/*++ Copyright (C) 1993-1999 Microsoft Corporation Module Name: control.cpp Abstract: Implementation of ISystemMonitor, IOleControl, ISpecifyPP, IProvideClassInfo interfaces. --*/ #include "polyline.h" #include "unkhlpr.h" #include "unihelpr.h" #include "ctrprop.h" #include "grphprop.h" #include "genprop.h" #include "appearprop.h" #include "logsrc.h" #include "srcprop.h" //---------------------------------------------------------------------------- // CImpISpecifyPP Interface Implementation //---------------------------------------------------------------------------- // Standard IUnknown for contained interface IMPLEMENT_CONTAINED_INTERFACE(CPolyline, CImpISpecifyPP) STDMETHODIMP CImpISpecifyPP::GetPages ( OUT CAUUID *pPages ) /*++ Routine Description: GetPages returns an allocated array of property page GUIDs for Sysmon graph. There are three pages: general, graph, and counter. Arguments: pPages - Pointer to GUID array header filled in by this routine Return Value: HRESULT - NOERROR or OUT_OF_MEMORY --*/ { HRESULT hr = E_POINTER; IMalloc *pIMalloc = NULL; GUID *pGUID = NULL; if ( NULL != pPages ) { pPages->cElems = 0; pPages->pElems = NULL; // Get Ole Malloc and allocate array if ( FAILED(CoGetMalloc(MEMCTX_TASK, &pIMalloc)) ) return E_OUTOFMEMORY; pGUID = (GUID*)pIMalloc->Alloc((CPROPPAGES) * sizeof(GUID)); if (NULL != pGUID) { // Fill the structure pGUID[GENERAL_PROPPAGE] = CLSID_GeneralPropPage; pGUID[SOURCE_PROPPAGE] = CLSID_SourcePropPage; pGUID[COUNTER_PROPPAGE] = CLSID_CounterPropPage; pGUID[GRAPH_PROPPAGE] = CLSID_GraphPropPage; pGUID[APPEAR_PROPPAGE] = CLSID_AppearPropPage; pPages->cElems = CPROPPAGES; pPages->pElems = pGUID; } pIMalloc->Release(); hr = (NULL != pGUID) ? NOERROR : E_OUTOFMEMORY; } return hr; } //---------------------------------------------------------------------------- // CImpIProvideClassInfo Interface Implementation //---------------------------------------------------------------------------- // Standard IUnknown for contained interface IMPLEMENT_CONTAINED_INTERFACE(CPolyline, CImpIProvideClassInfo) STDMETHODIMP CImpIProvideClassInfo::GetClassInfo ( OUT LPTYPEINFO *ppTI ) /*++ Routine Description: GetClassInfo returns an ITypeInfo interface to its type lib information. The interface is obtained by querying the contained ITypeLib interface. Arguments: ppTI - Pointer to returned ITypeInfo interface Return Value: HRESULT --*/ { if (NULL == ppTI) return E_POINTER; *ppTI = NULL; return m_pObj->m_pITypeLib->GetTypeInfoOfGuid(CLSID_SystemMonitor, ppTI); } //---------------------------------------------------------------------------- // CImpISystemMonitor Interface Implementation //---------------------------------------------------------------------------- // Standard IUnknown for contained interface IMPLEMENT_CONTAINED_INTERFACE(CPolyline, CImpISystemMonitor) STDMETHODIMP CImpISystemMonitor::put_Appearance ( IN INT iAppearance ) { HRESULT hr = E_INVALIDARG; // 0 = Flat, 1 = 3D if ( ( 0 == iAppearance ) || ( 1 == iAppearance ) ) { m_pObj->m_pCtrl->put_Appearance( iAppearance, FALSE ); hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::get_Appearance ( OUT INT *piAppearance ) { HRESULT hr = E_POINTER; if ( NULL != piAppearance ) { *piAppearance = m_pObj->m_Graph.Options.iAppearance; if (*piAppearance == NULL_APPEARANCE) *piAppearance = m_pObj->m_pCtrl->Appearance(); hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_BackColor ( IN OLE_COLOR Color ) { m_pObj->m_pCtrl->put_BackPlotColor(Color, FALSE); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_BackColor ( OUT OLE_COLOR *pColor ) { HRESULT hr = E_POINTER; if ( NULL != pColor ) { *pColor = m_pObj->m_Graph.Options.clrBackPlot; if (*pColor == NULL_COLOR) *pColor = m_pObj->m_pCtrl->clrBackPlot(); hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_BackColorCtl ( IN OLE_COLOR Color ) { m_pObj->m_pCtrl->put_BackCtlColor(Color); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_BackColorCtl ( OUT OLE_COLOR *pColor ) { HRESULT hr = E_POINTER; if ( NULL != pColor ) { // NT 5.0 Beta 1 files can be saved with NULL BackColorCtl. *pColor = m_pObj->m_Graph.Options.clrBackCtl; if (*pColor == NULL_COLOR) *pColor = m_pObj->m_pCtrl->clrBackCtl(); hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_GridColor ( IN OLE_COLOR Color ) { m_pObj->m_pCtrl->put_GridColor(Color); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_GridColor ( OUT OLE_COLOR *pColor ) { HRESULT hr = E_POINTER; if ( NULL != pColor ) { *pColor = m_pObj->m_Graph.Options.clrGrid; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_TimeBarColor ( IN OLE_COLOR Color ) { m_pObj->m_pCtrl->put_TimeBarColor(Color); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_TimeBarColor ( OUT OLE_COLOR *pColor ) { HRESULT hr = E_POINTER; if ( NULL != pColor ) { *pColor = m_pObj->m_Graph.Options.clrTimeBar; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_BorderStyle ( IN INT iBorderStyle ) { HRESULT hr; // 0 = none, 1 = single. if ( ( 0 == iBorderStyle ) || ( 1 == iBorderStyle ) ) { m_pObj->m_pCtrl->put_BorderStyle( iBorderStyle, FALSE ); hr = NOERROR; } else { hr = E_INVALIDARG; } return hr; } STDMETHODIMP CImpISystemMonitor::get_BorderStyle ( OUT INT *piBorderStyle ) { HRESULT hr = E_POINTER; if ( NULL != piBorderStyle ) { *piBorderStyle = m_pObj->m_Graph.Options.iBorderStyle; if (*piBorderStyle == NULL_BORDERSTYLE) *piBorderStyle = m_pObj->m_pCtrl->BorderStyle(); hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_ForeColor ( IN OLE_COLOR Color ) { m_pObj->m_pCtrl->put_FgndColor(Color, FALSE); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_ForeColor ( OUT OLE_COLOR *pColor ) { HRESULT hr = E_POINTER; if ( NULL != pColor ) { *pColor = m_pObj->m_Graph.Options.clrFore; if (*pColor == NULL_COLOR) *pColor = m_pObj->m_pCtrl->clrFgnd(); hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::putref_Font ( IN IFontDisp *pFontDisp ) { LPFONT pIFont; HRESULT hr; if ( NULL == pFontDisp ) { hr = E_POINTER; } else { hr = pFontDisp->QueryInterface(IID_IFont, (PPVOID)&pIFont); if (SUCCEEDED(hr)) { hr = m_pObj->m_pCtrl->put_Font ( pIFont, FALSE ); } pIFont->Release(); } return hr; } STDMETHODIMP CImpISystemMonitor::get_Font ( OUT IFontDisp **ppFont ) { HRESULT hr = E_POINTER; if ( NULL != ppFont ) { hr = m_pObj->m_pCtrl->m_OleFont.GetFontDisp(ppFont); } return hr; } STDMETHODIMP CImpISystemMonitor::put_ShowVerticalGrid ( IN VARIANT_BOOL bVisible ) /*++ Routine Description: Shows/hides the vertical grid. Arguments: bVisible - Visibility (TRUE = show, FALSE = hide) Return Value: HRESULT --*/ { m_pObj->m_Graph.Options.bVertGridChecked = bVisible; m_pObj->m_pCtrl->UpdateGraph(UPDGRPH_PLOT); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_ShowVerticalGrid ( OUT VARIANT_BOOL *pbState ) /*++ Routine Description: Gets the vertical grid visibility state. Arguments: pbState - pointer to returned state (TRUE = visible, FALSE = hidden) Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != pbState ) { *pbState = (short)m_pObj->m_Graph.Options.bVertGridChecked; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_ShowHorizontalGrid( IN VARIANT_BOOL bVisible ) /*++ Routine Description: Shows/hides the horizontal grid. Arguments: bVisible - Visibility (TRUE = show, FALSE = hide) Return Value: HRESULT --*/ { m_pObj->m_Graph.Options.bHorzGridChecked = bVisible; m_pObj->m_pCtrl->UpdateGraph(UPDGRPH_PLOT); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_ShowHorizontalGrid ( OUT VARIANT_BOOL *pbState ) /*++ Routine Description: Gets the horizontal grid visibility state. Arguments: pbState - pointer to returned state (TRUE = visible, FALSE = hidden) Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != pbState ) { *pbState = (short)m_pObj->m_Graph.Options.bHorzGridChecked; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_Highlight( IN VARIANT_BOOL bState ) /*++ Routine Description: Sets the highlight state. If true, the selected counter is always highlighted in the graph. Arguments: bState - Highlight (TRUE = highlight, FALSE = no highlight) Return Value: HRESULT --*/ { m_pObj->m_pCtrl->put_Highlight(bState); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_Highlight ( OUT VARIANT_BOOL *pbState ) /*++ Routine Description: Gets the highlight state. Arguments: pbState - pointer to returned state (TRUE = highlight, FALSE = no highlight) Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != pbState ) { *pbState = (short)m_pObj->m_Graph.Options.bHighlight; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_ShowLegend ( IN VARIANT_BOOL bState ) /*++ Routine Description: Shows/hides the graph legend. Arguments: bVisible - Visibility (TRUE = show, FALSE = hide) Return Value: HRESULT --*/ { m_pObj->m_Graph.Options.bLegendChecked = bState; m_pObj->m_pCtrl->UpdateGraph(UPDGRPH_LAYOUT); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_ShowLegend ( OUT VARIANT_BOOL *pbState ) /*++ Routine Description: Gets the legend visibility state. Arguments: pbState - pointer to returned state (TRUE = visible, FALSE = hidden) Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != pbState ) { *pbState = (short)m_pObj->m_Graph.Options.bLegendChecked; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_ShowToolbar ( IN VARIANT_BOOL bState ) /*++ Routine Description: Shows/hides the graph toolbar Arguments: bState = Visibility (TRUE = show, FALSE = hide) Return Value: HRESULT --*/ { m_pObj->m_Graph.Options.bToolbarChecked = bState; m_pObj->m_pCtrl->UpdateGraph(UPDGRPH_LAYOUT); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_ShowToolbar ( OUT VARIANT_BOOL *pbState ) /*++ Routine Description: Gets the legend visibility state. Arguments: pbState - pointer to returned state (TRUE = visible, FALSE = hidden) Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != pbState ) { *pbState = (short)m_pObj->m_Graph.Options.bToolbarChecked; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_ShowScaleLabels ( IN VARIANT_BOOL bState ) /*++ Routine Description: Shows/hides the vertical scale numbers. Arguments: bVisible - Visibility (TRUE = show, FALSE = hide) Return Value: HRESULT --*/ { m_pObj->m_Graph.Options.bLabelsChecked = bState; m_pObj->m_pCtrl->UpdateGraph(UPDGRPH_LAYOUT); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_ShowScaleLabels ( OUT VARIANT_BOOL *pbState ) /*++ Routine Description: Gets the visibility state of the vertical scale numbers. Arguments: pbState - pointer to returned state (TRUE = visible, FALSE = hidden) Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != pbState ) { *pbState = (short)m_pObj->m_Graph.Options.bLabelsChecked; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_ShowValueBar ( IN VARIANT_BOOL bState ) /*++ Routine Description: Shows/hides the graph statistics bar. Arguments: bVisible - Visibility (TRUE = show, FALSE = hide) Return Value: HRESULT --*/ { m_pObj->m_Graph.Options.bValueBarChecked = bState; m_pObj->m_pCtrl->UpdateGraph(UPDGRPH_LAYOUT); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_ShowValueBar( OUT VARIANT_BOOL *pbState ) /*++ Routine Description: Gets the statistics bar visibility state. Arguments: pbState - pointer to returned state (TRUE = visible, FALSE = hidden) Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != pbState ) { *pbState = (short)m_pObj->m_Graph.Options.bValueBarChecked; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_MaximumScale ( IN INT iValue ) /*++ Routine Description: Sets the vertical scale maximum value. Arguments: iValue - Maximum value Return Value: HRESULT --*/ { if ( ( iValue <= MAX_VERTICAL_SCALE ) && (iValue > m_pObj->m_Graph.Options.iVertMin ) ) { m_pObj->m_Graph.Options.iVertMax = iValue; m_pObj->m_Graph.Scale.SetMaxValue(iValue); m_pObj->m_pCtrl->UpdateGraph(UPDGRPH_LAYOUT); return NOERROR; } else { return E_INVALIDARG; } } STDMETHODIMP CImpISystemMonitor::get_MaximumScale ( OUT INT *piValue ) /*++ Routine Description: Gets the vertical scale's maximum value. Arguments: piValue = pointer to returned value Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != piValue ) { *piValue = m_pObj->m_Graph.Options.iVertMax; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_MinimumScale ( IN INT iValue ) /*++ Routine Description: Sets the vertical scale minimum value. Arguments: iValue - Minimum value Return Value: None. --*/ { if ( ( iValue >= MIN_VERTICAL_SCALE ) && (iValue < m_pObj->m_Graph.Options.iVertMax ) ) { m_pObj->m_Graph.Options.iVertMin = iValue; m_pObj->m_Graph.Scale.SetMinValue(iValue); m_pObj->m_pCtrl->UpdateGraph(UPDGRPH_LAYOUT); return NOERROR; } else { return E_INVALIDARG; } } STDMETHODIMP CImpISystemMonitor::get_MinimumScale ( OUT INT *piValue ) /*++ Routine Description: Gets the vertical scale's minimum value. Arguments: piValue = pointer to returned value Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != piValue ) { *piValue = m_pObj->m_Graph.Options.iVertMin; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_UpdateInterval ( IN FLOAT fValue ) /*++ Routine Description: Sets the graph sample interval. Arguments: fValue - Update interval in seconds (can be fraction) Return Value: HRESULT --*/ { if ( ( fValue >= MIN_UPDATE_INTERVAL ) && (fValue <= MAX_UPDATE_INTERVAL ) ) { m_pObj->m_Graph.Options.fUpdateInterval = fValue; m_pObj->m_pCtrl->SetIntervalTimer(); return NOERROR; } else { return E_INVALIDARG; } } STDMETHODIMP CImpISystemMonitor::get_UpdateInterval ( OUT FLOAT *pfValue ) /*++ Routine Description: Gets the graph's sample interval measured in seconds. Arguments: pfValue = pointer to returned value Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != pfValue ) { *pfValue = m_pObj->m_Graph.Options.fUpdateInterval; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_DisplayFilter ( IN INT iValue ) /*++ Routine Description: Sets the graph display filter - samples per display interval. Arguments: iValue - Update interval in samples Return Value: HRESULT --*/ { if ( iValue > 0 ) { // TodoDisplayFilter: Support for display filter > sample filter. if ( 1 == iValue ) { // TodoDisplayFilter: Display filter units = seconds instead of samples m_pObj->m_Graph.Options.iDisplayFilter = iValue; // m_pObj->m_pCtrl->SetIntervalTimer(); return NOERROR; } else { return E_INVALIDARG; } } else { return E_INVALIDARG; } } STDMETHODIMP CImpISystemMonitor::get_DisplayFilter ( OUT INT *piValue ) /*++ Routine Description: Gets the graph's display interval measured in samples. Arguments: piValue = pointer to returned value Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != piValue ) { *piValue = m_pObj->m_Graph.Options.iDisplayFilter; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_DisplayType ( IN eDisplayTypeConstant eDisplayType ) /*++ Routine Description: Selects display type (1 = line plot, 2 = histogram, 3 = Report) Arguments: eDisplayType - Display type Return Value: HRESULT --*/ { INT iUpdate; if (eDisplayType < LINE_GRAPH || eDisplayType > REPORT_GRAPH) return E_INVALIDARG; if (m_pObj->m_Graph.Options.iDisplayType == REPORT_GRAPH || eDisplayType == REPORT_GRAPH) iUpdate = UPDGRPH_VIEW; else iUpdate = UPDGRPH_PLOT; m_pObj->m_Graph.Options.iDisplayType = eDisplayType; m_pObj->m_pCtrl->UpdateGraph(iUpdate); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_DisplayType ( OUT eDisplayTypeConstant *peDisplayType ) /*++ Routine Description: Get graph display type (1 = line plot, 2 = histogram, 3 = Report) Arguments: peDisplayType = pointer to returned value Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != peDisplayType ) { *peDisplayType = (eDisplayTypeConstant)m_pObj->m_Graph.Options.iDisplayType; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_ManualUpdate ( IN VARIANT_BOOL bMode ) /*++ Routine Description: Sets/clears manual update mode. Manual mode suspends periodic updates of the graph. Arguments: bMode - Manual mode (TRUE = On, FALSE = Off) Return Value: HRESULT --*/ { m_pObj->m_pCtrl->put_ManualUpdate ( bMode ); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_ManualUpdate ( OUT VARIANT_BOOL *pbState ) /*++ Routine Description: Gets manual update mode. Arguments: pbState = pointer to returned state (TRUE = On, FALSE = Off) Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != pbState ) { *pbState = (short)m_pObj->m_Graph.Options.bManualUpdate; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_GraphTitle ( IN BSTR bstrTitle ) /*++ Routine Description: Sets the graph title. Arguments: bstrTitle - Title string Return Value: HRESULT --*/ { LPTSTR pszTemp; LPTSTR pszTitle; USES_CONVERSION if ( (bstrTitle == NULL) || (bstrTitle[0] == 0) ) { delete m_pObj->m_Graph.Options.pszGraphTitle; m_pObj->m_Graph.Options.pszGraphTitle = NULL; } else { pszTemp = W2T(bstrTitle); pszTitle = new TCHAR [lstrlen(pszTemp) + 1]; if (pszTitle) { lstrcpy(pszTitle, pszTemp); delete m_pObj->m_Graph.Options.pszGraphTitle; m_pObj->m_Graph.Options.pszGraphTitle = pszTitle; } else { return E_OUTOFMEMORY; } } m_pObj->m_pCtrl->UpdateGraph(UPDGRPH_LAYOUT); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_GraphTitle ( BSTR *pbsTitle ) /*++ Routine Description: Gets the graph title string. The caller is responsible for releasing the string memory. Arguments: pbsTitle - pointer to returned title (BSTR) Return Value: HResult --*/ { HRESULT hr = E_POINTER; USES_CONVERSION if ( NULL != pbsTitle ) { *pbsTitle = NULL; if (m_pObj->m_Graph.Options.pszGraphTitle != NULL) { *pbsTitle = SysAllocString(T2W(m_pObj->m_Graph.Options.pszGraphTitle)); if (*pbsTitle == NULL) hr = E_OUTOFMEMORY; } hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_LogFileName ( IN BSTR bstrLogFile ) /*++ Routine Description: Sets the log file name Arguments: bstrLogFile - File name string Return Value: HRESULT --*/ { HRESULT hr = S_OK; LPTSTR pszLogFile = NULL; LONG lCount; USES_CONVERSION // Ensure that the current log file count is 0 or 1 lCount = m_pObj->m_pCtrl->NumLogFiles(); // Get the current data source type if ( 0 == lCount || 1 == lCount ) { // Reset the data source type to null data source while completing this operation. // TodoLogFiles: Possible to keep the previous put_LogFileName semantics, // where new query is opened (successfully) before closing the previous query? hr = m_pObj->m_pCtrl->put_DataSourceType ( sysmonNullDataSource ); if ( SUCCEEDED ( hr ) ) { // TodoLogFiles: What if multiple files exist? Probably return error re: not supported. if ( 1 == lCount ) { hr = m_pObj->m_pCtrl->RemoveSingleLogFile ( m_pObj->m_pCtrl->FirstLogFile() ); } if ( SUCCEEDED ( hr ) ) { // Check name if (bstrLogFile != NULL && bstrLogFile[0] != 0) { // If non-null name // Convert from BSTR to internal string, then add the item. pszLogFile = W2T(bstrLogFile); hr = m_pObj->m_pCtrl->AddSingleLogFile ( pszLogFile ); if ( SUCCEEDED ( hr ) ) { // put_DataSourceType attempts to set the data source type to sysmonCurrentActivity // if sysmonLogFiles fails. hr = m_pObj->m_pCtrl->put_DataSourceType ( sysmonLogFiles ); } } } } } else { hr = E_INVALIDARG; } return hr; } STDMETHODIMP CImpISystemMonitor::get_LogFileName ( BSTR *pbsLogFile ) /*++ Routine Description: Gets the log file name. The caller is responsible for releasing the string memory. This is an obsolete method supported only for backward compatibility. It cannot be used when multiple log files are loaded. Arguments: pbsLogFile - pointer to returned name (BSTR) Return Value: HResult --*/ { HRESULT hr = NOERROR; LPCTSTR pszFileName = NULL; LPTSTR pszLogFile = NULL; ULONG LogFileSize = 0; CLogFileItem * pLogFile; LPTSTR pszLogFileCurrent; USES_CONVERSION if (NULL != pbsLogFile) { *pbsLogFile = NULL; pLogFile = m_pObj->m_pCtrl->FirstLogFile(); while (pLogFile) { pszFileName = pLogFile->GetPath(); LogFileSize += (lstrlen(pszFileName) + 1); pLogFile = pLogFile->Next(); } LogFileSize ++; // for the final NULL character pszLogFile = (LPTSTR) malloc(LogFileSize * sizeof(TCHAR)); if (pszLogFile) { pLogFile = m_pObj->m_pCtrl->FirstLogFile(); pszLogFileCurrent = pszLogFile; while (pLogFile) { pszFileName = pLogFile->GetPath(); lstrcpy(pszLogFileCurrent, pszFileName); pszLogFileCurrent += lstrlen(pszFileName); * pszLogFileCurrent = _T('\0'); pszLogFileCurrent ++; pLogFile = pLogFile->Next(); } * pszLogFileCurrent = _T('\0'); * pbsLogFile = SysAllocStringLen(pszLogFile, LogFileSize); if (NULL == * pbsLogFile) { hr = E_OUTOFMEMORY; } free(pszLogFile); } else { hr = E_OUTOFMEMORY; } } else { hr = E_POINTER; } return hr; } STDMETHODIMP CImpISystemMonitor::put_DataSourceType ( IN eDataSourceTypeConstant eDataSourceType ) /*++ Routine Description: Selects data source type (1 = current activity, 2 = log files) Arguments: eDataSourceType - Data source type Return Value: HRESULT --*/ { if ( eDataSourceType != sysmonCurrentActivity && eDataSourceType != sysmonLogFiles && sysmonNullDataSource != eDataSourceType && eDataSourceType != sysmonSqlLog) { return E_INVALIDARG; } return m_pObj->m_pCtrl->put_DataSourceType( eDataSourceType ); } STDMETHODIMP CImpISystemMonitor::get_DataSourceType ( OUT eDataSourceTypeConstant *peDataSourceType ) /*++ Routine Description: Get data source type (1 = current activity, 2 = log files) Arguments: peDataSourceType = pointer to returned value Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != peDataSourceType ) { hr = m_pObj->m_pCtrl->get_DataSourceType ( *peDataSourceType ); } return hr; } STDMETHODIMP CImpISystemMonitor::get_LogFiles ( ILogFiles **ppILogFiles ) { HRESULT hr = E_POINTER; if ( NULL != ppILogFiles ) { *ppILogFiles = m_pObj->m_pImpILogFiles; if ( NULL != *ppILogFiles ) { (*ppILogFiles)->AddRef(); } hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_LogViewStart ( IN DATE dateStart ) { LONGLONG llTestStart; if ( VariantDateToLLTime(dateStart, &llTestStart ) ) { // No error. If start time is past current stop time, reset it to the current stop time. if ( llTestStart <= m_pObj->m_pCtrl->m_DataSourceInfo.llStopDisp ){ if ( llTestStart >= m_pObj->m_pCtrl->m_DataSourceInfo.llBeginTime ) { m_pObj->m_pCtrl->m_DataSourceInfo.llStartDisp = llTestStart; } else { m_pObj->m_pCtrl->m_DataSourceInfo.llStartDisp = m_pObj->m_pCtrl->m_DataSourceInfo.llBeginTime; } } else { m_pObj->m_pCtrl->m_DataSourceInfo.llStartDisp = m_pObj->m_pCtrl->m_DataSourceInfo.llStopDisp; } m_pObj->m_pCtrl->UpdateGraph(UPDGRPH_LOGVIEW); return NOERROR; } else { return E_FAIL; } } STDMETHODIMP CImpISystemMonitor::get_LogViewStart ( OUT DATE *pdateStart ) { HRESULT hr = E_POINTER; if ( NULL != pdateStart ) { if (LLTimeToVariantDate(m_pObj->m_pCtrl->m_DataSourceInfo.llStartDisp, pdateStart)) hr = NOERROR; else hr = E_FAIL; } return hr; } STDMETHODIMP CImpISystemMonitor::put_LogViewStop ( IN DATE dateStop ) { LONGLONG llTestStop; if ( VariantDateToLLTime(dateStop, &llTestStop ) ) { // No error. If requested stop time is earlier than current start time, set it to // the current start time. if ( llTestStop >= m_pObj->m_pCtrl->m_DataSourceInfo.llStartDisp ) { if ( llTestStop <= m_pObj->m_pCtrl->m_DataSourceInfo.llEndTime ) { m_pObj->m_pCtrl->m_DataSourceInfo.llStopDisp = llTestStop; } else { m_pObj->m_pCtrl->m_DataSourceInfo.llStopDisp = m_pObj->m_pCtrl->m_DataSourceInfo.llEndTime; } } else { m_pObj->m_pCtrl->m_DataSourceInfo.llStopDisp = m_pObj->m_pCtrl->m_DataSourceInfo.llStartDisp; } m_pObj->m_pCtrl->UpdateGraph(UPDGRPH_LOGVIEW); return NOERROR; } else { return E_FAIL; } } STDMETHODIMP CImpISystemMonitor::get_LogViewStop ( OUT DATE *pdateStop ) { HRESULT hr = E_POINTER; if ( NULL != pdateStop ) { if (LLTimeToVariantDate(m_pObj->m_pCtrl->m_DataSourceInfo.llStopDisp, pdateStop)) hr = NOERROR; else hr = E_FAIL; } return hr; } STDMETHODIMP CImpISystemMonitor::put_YAxisLabel ( IN BSTR bstrLabel ) /*++ Routine Description: Sets the Y axis label string. Arguments: bstrLabel - Label string Return Value: HRESULT --*/ { LPTSTR pszTemp = NULL; LPTSTR pszTitle = NULL; USES_CONVERSION if ( (bstrLabel == NULL) || (bstrLabel[0] == 0) ) { delete m_pObj->m_Graph.Options.pszYaxisTitle; m_pObj->m_Graph.Options.pszYaxisTitle = NULL; } else { pszTemp = W2T(bstrLabel); pszTitle = new TCHAR [lstrlen(pszTemp) + 1]; if (pszTitle) { lstrcpy(pszTitle, pszTemp); delete m_pObj->m_Graph.Options.pszYaxisTitle; m_pObj->m_Graph.Options.pszYaxisTitle = pszTitle; } else { return E_OUTOFMEMORY; } } m_pObj->m_pCtrl->UpdateGraph(UPDGRPH_LAYOUT); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_YAxisLabel ( BSTR *pbsTitle ) /*++ Routine Description: Gets the Y axis title string. The caller is responsible for releasing the string memory. Arguments: pbsTitle - pointer to returned title (BSTR) Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; USES_CONVERSION if ( NULL != pbsTitle ) { *pbsTitle = NULL; if (m_pObj->m_Graph.Options.pszYaxisTitle != NULL) { *pbsTitle = SysAllocString(T2W(m_pObj->m_Graph.Options.pszYaxisTitle)); if (*pbsTitle != NULL) { hr = NOERROR; } else { hr = E_OUTOFMEMORY; } } } return hr; } STDMETHODIMP CImpISystemMonitor::get_Counters ( ICounters **ppICounters ) { HRESULT hr = E_POINTER; if ( NULL != ppICounters ) { *ppICounters = m_pObj->m_pImpICounters; (*ppICounters)->AddRef(); hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_ReadOnly ( IN VARIANT_BOOL bState ) { BOOL bStateLocal = FALSE; if ( bState ) bStateLocal = TRUE; m_pObj->m_Graph.Options.bReadOnly = bStateLocal; m_pObj->m_pCtrl->UpdateGraph(UPDGRPH_VIEW); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_ReadOnly ( OUT VARIANT_BOOL *pbState ) { HRESULT hr = E_POINTER; if ( NULL != pbState ) { *pbState = (short)m_pObj->m_Graph.Options.bReadOnly; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_ReportValueType ( IN eReportValueTypeConstant eReportValueType ) /*++ Routine Description: Selects report value type 0 = default value (current for live data, average for log file) 1 = current value 2 = average over the graph display interval 3 = minimum for the graph display interval 4 = maximum for the graph display interval Arguments: eReportValueType - Report valuex Return Value: HRESULT --*/ { if (eReportValueType < sysmonDefaultValue || eReportValueType > sysmonMaximum ) return E_INVALIDARG; m_pObj->m_Graph.Options.iReportValueType = eReportValueType; // Update the graph for both report and histogram views. if (m_pObj->m_Graph.Options.iDisplayType != LINE_GRAPH ) m_pObj->m_pCtrl->UpdateGraph(UPDGRPH_VIEW); return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_ReportValueType ( OUT eReportValueTypeConstant *peReportValueType ) /*++ Routine Description: Get report value type 0 = default value (current for live data, average for log file) 1 = current value 2 = average over the graph display interval 3 = minimum for the graph display interval 4 = maximum for the graph display interval Arguments: peReportValueType = pointer to returned value Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != peReportValueType ) { *peReportValueType = (eReportValueTypeConstant)m_pObj->m_Graph.Options.iReportValueType; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_MonitorDuplicateInstances( IN VARIANT_BOOL bState ) /*++ Routine Description: Allows/disallows monitoring of duplicate counter instances. Arguments: bState - TRUE = allow, FALSE = disallow) Return Value: HRESULT --*/ { m_pObj->m_Graph.Options.bMonitorDuplicateInstances = bState; return NOERROR; } STDMETHODIMP CImpISystemMonitor::get_MonitorDuplicateInstances ( OUT VARIANT_BOOL *pbState ) /*++ Routine Description: Gets the state of allowing monitoring of duplicate counter instances. Arguments: pbState - pointer to returned state ( TRUE = allow, FALSE = disallow ) Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; if ( NULL != pbState ) { *pbState = (short)m_pObj->m_Graph.Options.bMonitorDuplicateInstances; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::put_SqlDsnName ( IN BSTR bsSqlDsnName ) /*++ Routine Description: Sets the SQL logset DSN name. Return Value: HRESULT --*/ { HRESULT hr = NOERROR; LPTSTR szTemp = NULL; LPTSTR szSqlDsnName = NULL; USES_CONVERSION if ((bsSqlDsnName == NULL) || (bsSqlDsnName[0] == 0)) { if (m_pObj->m_pCtrl->m_DataSourceInfo.szSqlDsnName) { delete m_pObj->m_pCtrl->m_DataSourceInfo.szSqlDsnName; m_pObj->m_pCtrl->m_DataSourceInfo.szSqlDsnName = NULL; } } else { szTemp = W2T(bsSqlDsnName); szSqlDsnName = new TCHAR [lstrlen(szTemp) + 1]; if (szSqlDsnName) { lstrcpy(szSqlDsnName, szTemp); delete m_pObj->m_pCtrl->m_DataSourceInfo.szSqlDsnName; m_pObj->m_pCtrl->m_DataSourceInfo.szSqlDsnName = szSqlDsnName; } else { hr = E_OUTOFMEMORY; } } return hr; } STDMETHODIMP CImpISystemMonitor::get_SqlDsnName ( BSTR * bsSqlDsnName ) /*++ Routine Description: Gets SQL DSN name string. The caller is responsible for releasing the string memory. Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; USES_CONVERSION if (bsSqlDsnName != NULL) { * bsSqlDsnName = NULL; if (m_pObj->m_pCtrl->m_DataSourceInfo.szSqlDsnName != NULL) { * bsSqlDsnName = SysAllocString( T2W(m_pObj->m_pCtrl->m_DataSourceInfo.szSqlDsnName)); if (* bsSqlDsnName != NULL) { hr = NOERROR; } else { hr = E_OUTOFMEMORY; } } } return hr; } STDMETHODIMP CImpISystemMonitor::put_SqlLogSetName ( IN BSTR bsSqlLogSetName ) /*++ Routine Description: Sets the SQL logset DSN name. Return Value: HRESULT --*/ { HRESULT hr = NOERROR; LPTSTR szTemp = NULL; LPTSTR szSqlLogSetName = NULL; USES_CONVERSION if ((bsSqlLogSetName == NULL) || (bsSqlLogSetName[0] == 0)) { if (m_pObj->m_pCtrl->m_DataSourceInfo.szSqlLogSetName) { delete m_pObj->m_pCtrl->m_DataSourceInfo.szSqlLogSetName; m_pObj->m_pCtrl->m_DataSourceInfo.szSqlLogSetName = NULL; } } else { szTemp = W2T(bsSqlLogSetName); szSqlLogSetName = new TCHAR [lstrlen(szTemp) + 1]; if (szSqlLogSetName) { lstrcpy(szSqlLogSetName, szTemp); delete m_pObj->m_pCtrl->m_DataSourceInfo.szSqlLogSetName; m_pObj->m_pCtrl->m_DataSourceInfo.szSqlLogSetName = szSqlLogSetName; } else { hr = E_OUTOFMEMORY; } } return hr; } STDMETHODIMP CImpISystemMonitor::get_SqlLogSetName ( BSTR * bsSqlLogSetName ) /*++ Routine Description: Gets SQL DSN name string. The caller is responsible for releasing the string memory. Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; USES_CONVERSION if (bsSqlLogSetName != NULL) { * bsSqlLogSetName = NULL; if (m_pObj->m_pCtrl->m_DataSourceInfo.szSqlLogSetName != NULL) { * bsSqlLogSetName = SysAllocString( T2W(m_pObj->m_pCtrl->m_DataSourceInfo.szSqlLogSetName)); if (* bsSqlLogSetName != NULL) { hr = NOERROR; } else { hr = E_OUTOFMEMORY; } } } return hr; } STDMETHODIMP CImpISystemMonitor::Counter ( IN INT iIndex, OUT ICounterItem **ppItem ) /*++ Routine Description: Gets the ICounterItem interface for an indexed counter. Index is one-based. Arguments: iIndex - Index of counter (0-based) ppItem - pointer to returned interface pointer Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; CGraphItem *pGItem; INT i; if ( NULL != ppItem ) { *ppItem = NULL; // Check for valid index if (iIndex < 0 || iIndex >= m_pObj->m_Graph.CounterTree.NumCounters()) return E_INVALIDARG; // Traverse counter linked list to indexed item pGItem = m_pObj->m_Graph.CounterTree.FirstCounter(); i = 0; while (i++ < iIndex && pGItem != NULL) { pGItem = pGItem->Next(); } if (pGItem == NULL) return E_FAIL; pGItem->AddRef(); *ppItem = pGItem; hr = NOERROR; } return hr; } STDMETHODIMP CImpISystemMonitor::AddCounter ( IN BSTR bstrPath, ICounterItem **ppItem ) /*++ Routine Description: Add counter specified by pathname to the control. This method supports wildcard paths. Arguments: bstrPath - Pathname string ppItem - pointer to returned interface pointer Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; USES_CONVERSION if ( NULL != ppItem ) { // Delegate to control object hr = m_pObj->m_pCtrl->AddCounter(W2T(bstrPath), (CGraphItem**)ppItem); } return hr; } STDMETHODIMP CImpISystemMonitor::DeleteCounter ( IN ICounterItem *pItem ) /*++ Routine Description: Deletes a counter from the control. Arguments: pItem - Pointer to counter's ICounterItem interface Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; USES_CONVERSION if ( NULL != pItem ) { // Delegate to control object hr = m_pObj->m_pCtrl->DeleteCounter((PCGraphItem)pItem, TRUE); } return hr; } STDMETHODIMP CImpISystemMonitor::UpdateGraph ( VOID ) /*++ Routine Description: Apply pending visual changes to control. This routine must be called after changing a counter's attributes. Arguments: None. Return Value: HRESULT --*/ { // Delegate to control object m_pObj->m_pCtrl->UpdateGraph(0); return NOERROR; } STDMETHODIMP CImpISystemMonitor::CollectSample( VOID ) /*++ Routine Description: Take a sample of all the counters assigned to the control. Arguments: None. Return Value: HRESULT. --*/ { // Request control to do a manual counter update if (m_pObj->m_pCtrl->UpdateCounterValues(TRUE) == 0) return NOERROR; else return E_FAIL; } STDMETHODIMP CImpISystemMonitor::BrowseCounters( VOID ) /*++ Routine Description: Display the browse counter dialog to allow counters to be added. Arguments: None. Return Value: HRESULT. --*/ { // Delegate to control return m_pObj->m_pCtrl->AddCounters(); } STDMETHODIMP CImpISystemMonitor::DisplayProperties( VOID ) /*++ Routine Description: Display the graph control property pages Arguments: None. Return Value: HRESULT. --*/ { // Delegate to control return m_pObj->m_pCtrl->DisplayProperties(); } STDMETHODIMP CImpISystemMonitor::Paste () /*++ Routine Description: Pastes a list of counter paths from the clipboard to the control Arguments: NULL Return Value: HRESULT --*/ { // Delegate to control object return m_pObj->m_pCtrl->Paste(); } STDMETHODIMP CImpISystemMonitor::Copy () /*++ Routine Description: Copies a list of counter paths from the control to the clipboard Arguments: NULL Return Value: HRESULT --*/ { // Delegate to control object return m_pObj->m_pCtrl->Copy(); } STDMETHODIMP CImpISystemMonitor::Reset () /*++ Routine Description: deletes the current set of counters Arguments: NULL Return Value: HRESULT --*/ { // Delegate to control object return m_pObj->m_pCtrl->Reset(); } void CImpISystemMonitor::SetLogFileRange ( LONGLONG llBegin, LONGLONG llEnd ) /*++ Routine Description: Set the log file time range. This routine provides the Source property page a way to give range to the control, so that the control doesn't have to repeat the length PDH call to get it. Arguments: llBegin Begin time of the log (FILETIME format) llEnd End time of log (FILETIME format) Return Value: HRESULT. --*/ { m_pObj->m_pCtrl->m_DataSourceInfo.llBeginTime = llBegin; m_pObj->m_pCtrl->m_DataSourceInfo.llEndTime = llEnd; } void CImpISystemMonitor::GetLogFileRange ( LONGLONG *pllBegin, LONGLONG *pllEnd ) /*++ Routine Description: Get the log file time range. This routine provides the Source property page a way to get the range from the control, so it doesn't have to make the length PDH call to get it. Arguments: pllBegin ptr to returned begin time of the log (FILETIME format) pllEnd ptr to returned end time of log (FILETIME format) Return Value: HRESULT. --*/ { if ( NULL != pllBegin && NULL != pllEnd ) { *pllBegin = m_pObj->m_pCtrl->m_DataSourceInfo.llBeginTime; *pllEnd = m_pObj->m_pCtrl->m_DataSourceInfo.llEndTime; } } /* * The following methods, GetVisuals and SetVisuals, provide a means for the * counter property page to save the user's color settings between invocations. */ void CImpISystemMonitor::GetVisuals ( OUT OLE_COLOR *pColor, OUT INT *piColorIndex, OUT INT *piWidthIndex, OUT INT *piStyleIndex ) { if ( NULL != pColor && NULL != piColorIndex && NULL != piWidthIndex && NULL != piStyleIndex ) { *pColor = m_pObj->m_pCtrl->m_clrCounter; *piColorIndex = m_pObj->m_pCtrl->m_iColorIndex; *piWidthIndex = m_pObj->m_pCtrl->m_iWidthIndex; *piStyleIndex = m_pObj->m_pCtrl->m_iStyleIndex; } } void CImpISystemMonitor::SetVisuals ( IN OLE_COLOR Color, IN INT iColorIndex, IN INT iWidthIndex, IN INT iStyleIndex ) { OleTranslateColor( Color, NULL, &m_pObj->m_pCtrl->m_clrCounter ); m_pObj->m_pCtrl->m_iColorIndex = iColorIndex; m_pObj->m_pCtrl->m_iWidthIndex = iWidthIndex; m_pObj->m_pCtrl->m_iStyleIndex = iStyleIndex; } HRESULT CImpISystemMonitor::SetLogViewTempRange ( LONGLONG llStart, LONGLONG llStop ) /*++ Routine Description: Set the log view temporary time range. This routine provides the Source property page a way to give range to the control, so that the control can draw temporary timeline guides on the line graph. Arguments: llStart Temporary log view start time (FILETIME format) llEnd Temporary log view end time (FILETIME format) Return Value: HRESULT. --*/ { HRESULT hr; DATE dateStart; DATE dateStop; LONGLONG llConvertedStart = MIN_TIME_VALUE; LONGLONG llConvertedStop = MAX_TIME_VALUE; BOOL bContinue = TRUE; // Convert times to and from Variant date to strip off milliseconds. // This will make them match the start and stop times processed by put_LogView* // Special case MAX_TIME_VALUE, because that is the signal to not draw the stop // guide line. // Convert start time if ( LLTimeToVariantDate ( llStart, &dateStart ) ) { bContinue = VariantDateToLLTime (dateStart, &llConvertedStart ); } // Convert stop time if not MAX_TIME_VALUE if ( bContinue ) { if ( MAX_TIME_VALUE != llStop ) { if ( LLTimeToVariantDate ( llStop, &dateStop ) ) { bContinue = VariantDateToLLTime ( dateStop, &llConvertedStop ); } } else { llConvertedStop = MAX_TIME_VALUE; } } if ( bContinue ) { m_pObj->m_pCtrl->SetLogViewTempTimeRange ( llConvertedStart, llConvertedStop ); hr = NOERROR; } else { hr = E_FAIL; } return hr; } STDMETHODIMP CImpISystemMonitor::LogFile ( IN INT iIndex, OUT ILogFileItem **ppItem ) /*++ Routine Description: Gets the ILogFileItem interface for an indexed log file. Index is 0-based. Arguments: iIndex - Index of counter (0-based) ppItem - pointer to returned interface pointer Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; CLogFileItem *pItem; INT i; if ( NULL != ppItem ) { *ppItem = NULL; // Check for valid index if (iIndex >= 0 && iIndex < m_pObj->m_pCtrl->NumLogFiles()) { // Traverse counter linked list to indexed item pItem = m_pObj->m_pCtrl->FirstLogFile(); i = 0; while (i++ < iIndex && pItem != NULL) { pItem = pItem->Next(); } if (pItem != NULL) { pItem->AddRef(); *ppItem = pItem; hr = NOERROR; } else { hr = E_FAIL; } } else { hr = E_INVALIDARG; } } return hr; } STDMETHODIMP CImpISystemMonitor::AddLogFile ( IN BSTR bstrPath, ILogFileItem **ppItem ) /*++ Routine Description: Add log file specified by pathname to the control. This method does not support wildcard paths. Arguments: bstrPath - Pathname string ppItem - pointer to returned interface pointer Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; USES_CONVERSION if ( NULL != ppItem ) { // TodoLogFiles: AddSingleLogFile should check for duplicate file names. // If duplicate, return special status, ala AddCounter // Delegate to control object hr = m_pObj->m_pCtrl->AddSingleLogFile(W2T(bstrPath), (CLogFileItem**)ppItem); } return hr; } STDMETHODIMP CImpISystemMonitor::DeleteLogFile ( IN ILogFileItem *pItem ) /*++ Routine Description: Deletes a log file from the control. Arguments: pItem - Pointer to log file's ILogFileItem interface Return Value: HRESULT --*/ { HRESULT hr = E_POINTER; USES_CONVERSION if ( NULL != pItem ) { // Delegate to control object hr = m_pObj->m_pCtrl->RemoveSingleLogFile( (PCLogFileItem)pItem ); } return hr; } //IOleControl interface implementation /* * CImpIOleControl::CImpIOleControl * CImpIOleControl::~CImpIOleControl * * Parameters (Constructor): * pObj PCPolyline of the object we're in. * pUnkOuter LPUNKNOWN to which we delegate. */ CImpIOleControl::CImpIOleControl ( IN PCPolyline pObj, IN LPUNKNOWN pUnkOuter ) { m_cRef = 0; m_pObj = pObj; m_pUnkOuter = pUnkOuter; } CImpIOleControl::~CImpIOleControl ( VOID ) { return; } /* * CImpIOleControl::QueryInterface * CImpIOleControl::AddRef * CImpIOleControl::Release */ STDMETHODIMP CImpIOleControl::QueryInterface( IN REFIID riid, OUT LPVOID *ppv ) { return m_pUnkOuter->QueryInterface(riid, ppv); } STDMETHODIMP_( ULONG ) CImpIOleControl::AddRef( VOID ) { ++m_cRef; return m_pUnkOuter->AddRef(); } STDMETHODIMP_(ULONG) CImpIOleControl::Release(void) { --m_cRef; return m_pUnkOuter->Release(); } /* * CImpIOleControl::GetControlInfo * * Purpose: * Fills a CONTROLINFO structure containing information about * the controls mnemonics and other behavioral aspects. * * Parameters: * pCI LPCONTROLINFO to the structure to fill */ STDMETHODIMP CImpIOleControl::GetControlInfo ( LPCONTROLINFO pCI ) { if (NULL==pCI) return E_POINTER; *pCI=m_pObj->m_ctrlInfo; return E_NOTIMPL; } /* * CImpIOleControl::OnMnemonic * * Purpose: * Notifies the control that a mnemonic was activated. * * Parameters: * pMsg LPMSG containing the message that matches one of * the control's mnemonics. The control uses this * to distinguish which mnemonic was pressed. */ STDMETHODIMP CImpIOleControl::OnMnemonic ( LPMSG /* pMsg */ ) { //No mnemonics return NOERROR; } /* * CImpIOleControl::OnAmbientPropertyChange * * Purpose: * Notifies the control that one or more of the container's ambient * properties changed. * * Parameters: * dispID DISPID identifying the property, which can * be DISPID_UNKNOWN indicating that more than * one changed. */ STDMETHODIMP CImpIOleControl::OnAmbientPropertyChange(DISPID dispID) { /* */ DWORD dwInitWhich; switch (dispID) { case DISPID_UNKNOWN: { dwInitWhich = INITAMBIENT_SHOWHATCHING | INITAMBIENT_UIDEAD | INITAMBIENT_BACKCOLOR | INITAMBIENT_FORECOLOR | INITAMBIENT_APPEARANCE | INITAMBIENT_USERMODE | INITAMBIENT_FONT; // Update system colors here until MMC passes on WM_SYSCOLORCHANGE m_pObj->m_pCtrl->UpdateNonAmbientSysColors(); break; } case DISPID_AMBIENT_SHOWHATCHING: dwInitWhich = INITAMBIENT_SHOWHATCHING; break; case DISPID_AMBIENT_UIDEAD: dwInitWhich = INITAMBIENT_UIDEAD; break; case DISPID_AMBIENT_APPEARANCE: dwInitWhich = INITAMBIENT_APPEARANCE; break; case DISPID_AMBIENT_BACKCOLOR: dwInitWhich = INITAMBIENT_BACKCOLOR; break; case DISPID_AMBIENT_FORECOLOR: dwInitWhich = INITAMBIENT_FORECOLOR; break; case DISPID_AMBIENT_FONT: dwInitWhich = INITAMBIENT_FONT; break; case DISPID_AMBIENT_USERMODE: dwInitWhich = INITAMBIENT_USERMODE; break; default: return NOERROR; } m_pObj->AmbientsInitialize(dwInitWhich); return NOERROR; } /* * CImpIOleControl::FreezeEvents * * Purpose: * Instructs the control to stop firing events or to continue * firing them. * * Parameters: * fFreeze BOOL indicating to freeze (TRUE) or thaw (FALSE) * events from this control. */ STDMETHODIMP CImpIOleControl::FreezeEvents(BOOL fFreeze) { m_pObj->m_fFreezeEvents = fFreeze; return NOERROR; } // Private methods STDMETHODIMP CImpISystemMonitor::GetSelectedCounter ( ICounterItem** ppItem ) /*++ Routine Description: Gets the ICounterItem interface for the selected counter. Arguments: ppItem - pointer to returned interface pointer Return Value: HResult --*/ { HRESULT hr = E_POINTER; if ( NULL != ppItem ) { *ppItem = (m_pObj->m_pCtrl->m_pSelectedItem); if ( NULL != *ppItem ) { m_pObj->m_pCtrl->m_pSelectedItem->AddRef(); } hr = NOERROR; } return hr; } HLOG CImpISystemMonitor::GetDataSourceHandle ( void ) { return m_pObj->m_pCtrl->GetDataSourceHandle( ); } // *** TodoMultiLogHandle: Temporary method. Remove when trace file post-processing supports multiple // open files. HQUERY CImpISystemMonitor::GetQueryHandle ( void ) { return m_pObj->m_pCtrl->TempGetQueryHandle( ); }