C / C++ / MFC

#ifndef __CPUUSAGE_CLASS__
#define __CPUUSAGE_CLASS__
#include<pdh.h>



class CCPUUsage {     
public: 
  CCPUUsage();
  ~CCPUUsage();
#pragma message("CCPUUsage")
	BOOL Init(LONG nMinTicksBetweenSamples = 1000, int iProcessor = 0);

	int GetUsage(PBOOL pfNewSample = NULL);

private: 
  HQUERY m_hQuery;
  HCOUNTER m_hCounter;
  int m_nMinTicksBetweenSamples;
  DWORD m_msLastTick;
  int m_nLastSampledCPUUsage;
};


#endif // __CPUUSAGE_CLASS__

CArray<CCPUUsage*, CCPUUsage *> cpus;
int nCPUCount = 0;
while (TRUE)
    cpus[nCPUCount] = new CCPUUSAge();
    cpus[nCPUCount].Init(50,nCPUCount);
    if (cpus[nCPUCount].GetUsage == -1) break;
    nCPUCount++
}

// SysInfo.h : Declaration of the CSysInfo

#ifndef __SYSINFO_H_
#define __SYSINFO_H_

#include "resource.h"       // main symbols
#include <atlctl.h>
#include <wbemidl.h>

/////////////////////////////////////////////////////////////////////////////
// CSysInfo
class ATL_NO_VTABLE CSysInfo : 
	public CComObjectRootEx<CComSingleThreadModel>,
	public IDispatchImpl<ISysInfo, &IID_ISysInfo, &LIBID_SYSLOADLib>,
	public CComControl<CSysInfo>,
	public IPersistStreamInitImpl<CSysInfo>,
	public IOleControlImpl<CSysInfo>,
	public IOleObjectImpl<CSysInfo>,
	public IOleInPlaceActiveObjectImpl<CSysInfo>,
	public IViewObjectExImpl<CSysInfo>,
	public IOleInPlaceObjectWindowlessImpl<CSysInfo>,
	public ISupportErrorInfo,
	public CComCoClass<CSysInfo, &CLSID_SysInfo>
{
public:
	CSysInfo()
	{
		m_pUnkMarshaler = NULL;

	}


	~CSysInfo();

DECLARE_GET_CONTROLLING_UNKNOWN()
DECLARE_REGISTRY_RESOURCEID(IDR_SYSINFO)

DECLARE_PROTECT_FINAL_CONSTRUCT()

BEGIN_COM_MAP(CSysInfo)
	COM_INTERFACE_ENTRY(ISysInfo)
	COM_INTERFACE_ENTRY(IDispatch)
	COM_INTERFACE_ENTRY(IViewObjectEx)
	COM_INTERFACE_ENTRY(IViewObject2)
	COM_INTERFACE_ENTRY(IViewObject)
	COM_INTERFACE_ENTRY(IOleInPlaceObjectWindowless)
	COM_INTERFACE_ENTRY(IOleInPlaceObject)
	COM_INTERFACE_ENTRY2(IOleWindow, IOleInPlaceObjectWindowless)
	COM_INTERFACE_ENTRY(IOleInPlaceActiveObject)
	COM_INTERFACE_ENTRY(IOleControl)
	COM_INTERFACE_ENTRY(IOleObject)
	COM_INTERFACE_ENTRY(IPersistStreamInit)
	COM_INTERFACE_ENTRY2(IPersist, IPersistStreamInit)
	COM_INTERFACE_ENTRY(ISupportErrorInfo)
	COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal, m_pUnkMarshaler.p)
END_COM_MAP()

BEGIN_PROP_MAP(CSysInfo)
	PROP_DATA_ENTRY("_cx", m_sizeExtent.cx, VT_UI4)
	PROP_DATA_ENTRY("_cy", m_sizeExtent.cy, VT_UI4)
	// Example entries
	// PROP_ENTRY("Property Description", dispid, clsid)
	// PROP_PAGE(CLSID_StockColorPage)
END_PROP_MAP()

BEGIN_MSG_MAP(CSysInfo)
	CHAIN_MSG_MAP(CComControl<CSysInfo>)
	DEFAULT_REFLECTION_HANDLER()
END_MSG_MAP()
// Handler prototypes:
//  LRESULT MessageHandler(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
//  LRESULT CommandHandler(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
//  LRESULT NotifyHandler(int idCtrl, LPNMHDR pnmh, BOOL& bHandled);



	HRESULT FinalConstruct();

	void FinalRelease()
	{
		m_pUnkMarshaler.Release();
	}

	CComPtr<IUnknown> m_pUnkMarshaler;

// ISupportsErrorInfo
	STDMETHOD(InterfaceSupportsErrorInfo)(REFIID riid)
	{
		static const IID* arr[] = 
		{
			&IID_ISysInfo,
		};
		for (int i=0; i<sizeof(arr)/sizeof(arr[0]); i++)
		{
			if (InlineIsEqualGUID(*arr[i], riid))
				return S_OK;
		}
		return S_FALSE;
	}

// IViewObjectEx
	DECLARE_VIEW_STATUS(VIEWSTATUS_SOLIDBKGND | VIEWSTATUS_OPAQUE)

// ISysInfo
public:
	STDMETHOD(get_LoacPct)(/*[out, retval]*/ short *pVal);
	STDMETHOD(Load)();
	int LoadPercentage();

	HRESULT OnDraw(ATL_DRAWINFO& di)
	{
		RECT& rc = *(RECT*)di.prcBounds;
		Rectangle(di.hdcDraw, rc.left, rc.top, rc.right, rc.bottom);

		SetTextAlign(di.hdcDraw, TA_CENTER|TA_BASELINE);
		LPCTSTR pszText = _T("ATL 3.0 : SysInfo");
		TextOut(di.hdcDraw, 
			(rc.left + rc.right) / 2, 
			(rc.top + rc.bottom) / 2, 
			pszText, 
			lstrlen(pszText));

		return S_OK;
	}

	IWbemLocator *pLoc ;
    IWbemServices *pSvc ;
	IEnumWbemClassObject *pEnum;
	IWbemClassObject *pObj;
};

#endif //__SYSINFO_H_


// SysInfo.cpp : Implementation of CSysInfo

#include "stdafx.h"
#include <comdef.h>
#include "SysLoad.h"
#include "SysInfo.h"

/////////////////////////////////////////////////////////////////////////////
// CSysInfo

CSysInfo::~CSysInfo() {

	pObj->Release();

	pSvc->Release();
	pLoc->Release();     
	CoUninitialize();
}

int CSysInfo::LoadPercentage()
{

	return 0;

}

STDMETHODIMP CSysInfo::Load()
{


	return S_OK;
}
HRESULT CSysInfo::FinalConstruct()
	{
	try 
	{
		// Initialize COM
		HRESULT hres = CoInitializeEx(0, COINIT_MULTITHREADED);

		if(FAILED(hres))
		{
			throw 101;
		}
   
		/* 
		To obtain the initial namespace to the CIM Object Manager (CIMOM) on a particular 
		host machine, we use the IWbemLocator interface. As we will see soon, we access 
		CIMOM itself using the IWbemServices pointer, which is returned by the ConnectServer 
		method on this interface. But first of all, we have to create an instance of this 
		interface through the CoCreateInstance method. (More information on this method can 
		be found in the COM documentation of the Microsoft Platform SDK)
		*/

		hres = CoCreateInstance(CLSID_WbemLocator, 0, 
								CLSCTX_INPROC_SERVER, 
								IID_IWbemLocator, 
								(LPVOID *) &pLoc);
 
		if(FAILED(hres))
		{
			throw 102;
			
			// Release the COM context
			CoUninitialize();
			exit(1);
		}

		/* 
		Now it's time to create an instance of the main interface that connects to the WBEM 
		services. This interface provides management services to the client processes and to 
		other providers.
		Note that all outbound interfaces from any IWbemServices method should be initialized 
		to NULL before actually calling the method. We'll come back to this later on. First we 
		have to connect to the server. This is done, as we said before, by calling the ConnectServer 
		method of the IWbemLocator interface that we created before. Upon calling this method, we 
		have to specify the path to the server. This can either be local or a remote machine. The 
		most common path to the local server is \\\\.\\root\\cimv2
		*/


		hres = pLoc->ConnectServer(	_bstr_t(L"\\\\.\\root\\cimv2"), 
									NULL, NULL, 0, NULL, 0, 0,                                  
									&pSvc);

		if(FAILED(hres))
		{
			throw 103;
        
			// Release the locator object
			pLoc->Release();     
			CoUninitialize();
			exit(1);
		}

		
		
		/* 
		At this point in our program, we are actually connected to the WBEM services. Now, before 
		we can actually make calls on this proxy (Again, see COM documentation for more information
		on proxy's), we have to identify ourself. For convenience, we use the current logon-ID and 
		password, by which we gained access to windows. This is called "impersonation". 
		*/
		hres = CoSetProxyBlanket(	pSvc,
									RPC_C_AUTHN_WINNT,
									RPC_C_AUTHZ_NONE,
									NULL,
									RPC_C_AUTHN_LEVEL_CALL,
									RPC_C_IMP_LEVEL_IMPERSONATE,
									NULL,
									EOAC_NONE);

		if(FAILED(hres))
		{
			throw 104;
			// Release the services object
			pSvc->Release();
			pLoc->Release();
			CoUninitialize();
			exit(1);
		}

		/* 
		As mentioned at the beginning of this tutorial, the calls you make to WMI are based on a 
		specific language. In this case we use WQL, which is a variant of SQL. We will now ask WMI 
		to give us an object which holds information on the BIOS of our computer. We do this by 
		executing a query "select * from Win32_BIOS". A detailed description and class-hierarchy of 
		WMI can be found in the documentation.
		*/
		BSTR language = SysAllocString(L"WQL");
		BSTR query = SysAllocString(L"select * from Win32_Processor");
		


		/* 
		When we query WMI for objects, we need a place to store them. This is done with the 
		IEnumWbemClassObject interface. Once these objects are inside this enumeration object, we 
		can scroll through them and get their properties. But first, these object need to get 
		inside this enumeration object. Let's execute our previously defined query:
		*/
		hres = pSvc->ExecQuery(	language,
								query,
								WBEM_FLAG_FORWARD_ONLY,
								NULL,
								&pEnum);

		// Cleanup resources
		SysFreeString(query);
		SysFreeString(language);

		if(FAILED(hres))
		{
			throw 105;
		}
		else
		{
			// Define the object interface (AND initialize it to NULL)

			ULONG uReturned = 0;	// Used to check the number of objects returned

		
				hres = pEnum->Next(	0,
									1,
									&pObj,
									&uReturned);
		
				if(uReturned != 0) throw 106;
				

				/* 
				Once we have a pointer to our object, we can access it's properties. In this case, 
				we will be asking the object for a property named "Manufacturer". The value returned 
				by this call MUST be put inside a VARIANT variable, which in our case is v... I know, 
				a bit short but it'll do :)
	*/

			
		}
	} // end try
	catch (int iErr)
	{
	}

		
		return CoCreateFreeThreadedMarshaler(
			GetControllingUnknown(), &m_pUnkMarshaler.p);
	
	}
STDMETHODIMP CSysInfo::get_LoacPct(short *pVal)
{
				

			BSTR	strClassProp = SysAllocString(L"LoadPercentage");
			VARIANT	v;

			HRESULT hres = pObj->Get(strClassProp, 0, &v, 0, 0);
			SysFreeString(strClassProp);

			/* 
			If the property is found, convert our variant to a string and release the resources 
			hold by the variant, by calling VariantClear. Finally release the object
			*/
			if(!FAILED(hres))
			{
				*pVal = V_INT(&v);
			}

			VariantClear(&v);

	return S_OK;
}

if ( (HWND)lParam == slider->m_hWnd )