自学教程：C++ GetRunningObjectTable函数代码示例

static HRESULT WINAPI IHlinkBC_Register(IHlinkBrowseContext* iface,        DWORD dwReserved, IUnknown *piunk, IMoniker *pimk, DWORD *pdwRegister){    static const WCHAR szIdent[] = {'W','I','N','E','H','L','I','N','K',0};    HlinkBCImpl  *This = impl_from_IHlinkBrowseContext(iface);    IMoniker *mon;    IMoniker *composite;    IRunningObjectTable *ROT;    HRESULT hr;    FIXME("(%p)->(%i %p %p %p)/n", This, dwReserved, piunk, pimk, pdwRegister);    hr = CreateItemMoniker(NULL, szIdent, &mon);    if (FAILED(hr))        return hr;    CreateGenericComposite(mon, pimk, &composite);    GetRunningObjectTable(0, &ROT);    IRunningObjectTable_Register(ROT, 0, piunk, composite, pdwRegister);    IRunningObjectTable_Release(ROT);    IMoniker_Release(composite);    IMoniker_Release(mon);    return S_OK;}

/*********************************************************************** *		RegisterActiveObject (OLEAUT32.33) * * Registers an object in the global item table. * * PARAMS *  punk        [I] Object to register. *  rcid        [I] CLSID of the object. *  dwFlags     [I] Flags. *  pdwRegister [O] Address to store cookie of object registration in. * * RETURNS *  Success: S_OK. *  Failure: HRESULT code. */HRESULT WINAPI RegisterActiveObject(	LPUNKNOWN punk,REFCLSID rcid,DWORD dwFlags,LPDWORD pdwRegister) {	WCHAR 			guidbuf[80];	HRESULT			ret;	LPRUNNINGOBJECTTABLE	runobtable;	LPMONIKER		moniker;        DWORD                   rot_flags = ROTFLAGS_REGISTRATIONKEEPSALIVE; /* default registration is strong */	StringFromGUID2(rcid,guidbuf,39);	ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);	if (FAILED(ret))		return ret;	ret = GetRunningObjectTable(0,&runobtable);	if (FAILED(ret)) {		IMoniker_Release(moniker);		return ret;	}        if(dwFlags == ACTIVEOBJECT_WEAK)          rot_flags = 0;	ret = IRunningObjectTable_Register(runobtable,rot_flags,punk,moniker,pdwRegister);	IRunningObjectTable_Release(runobtable);	IMoniker_Release(moniker);	return ret;}

static voidRevokeObjectRegistration(    RegisteredInterp *riPtr){    LPRUNNINGOBJECTTABLE pROT = NULL;    HRESULT hr = S_OK;    if (riPtr->cookie != 0) {	hr = GetRunningObjectTable(0, &pROT);	if (SUCCEEDED(hr)) {	    hr = pROT->lpVtbl->Revoke(pROT, riPtr->cookie);	    pROT->lpVtbl->Release(pROT);	    riPtr->cookie = 0;	}    }    /*     * Release the name storage.     */    if (riPtr->name != NULL) {	free(riPtr->name);	riPtr->name = NULL;    }}

HRESULT AddGraphToRot(IUnknown *pUnkGraph, DWORD *pdwRegister) {    IMoniker * pMoniker;    IRunningObjectTable *pROT;    if (FAILED(GetRunningObjectTable(0, &pROT)))     {        return E_FAIL;    }    WCHAR wsz[128];    wsprintfW(wsz, L"FilterGraph %08x pid %08x", (DWORD_PTR)pUnkGraph,               GetCurrentProcessId());    HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);    if (SUCCEEDED(hr))     {        // Use the ROTFLAGS_REGISTRATIONKEEPSALIVE to ensure a strong reference        // to the object.  Using this flag will cause the object to remain        // registered until it is explicitly revoked with the Revoke() method.        //        // Not using this flag means that if GraphEdit remotely connects        // to this graph and then GraphEdit exits, this object registration         // will be deleted, causing future attempts by GraphEdit to fail until        // this application is restarted or until the graph is registered again.        hr = pROT->Register(ROTFLAGS_REGISTRATIONKEEPSALIVE, pUnkGraph,                             pMoniker, pdwRegister);        pMoniker->Release();    }    pROT->Release();    return hr;}

HRESULTAddGraphToRunningObjectTable(IUnknown *aUnkGraph, DWORD *aOutRotRegister){  HRESULT hr;  nsRefPtr<IMoniker> moniker;  nsRefPtr<IRunningObjectTable> runningObjectTable;  hr = GetRunningObjectTable(0, getter_AddRefs(runningObjectTable));  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);  const size_t STRING_LENGTH = 256;  WCHAR wsz[STRING_LENGTH];  StringCchPrintfW(wsz,                   STRING_LENGTH,                   L"FilterGraph %08x pid %08x",                   (DWORD_PTR)aUnkGraph,                   GetCurrentProcessId());  hr = CreateItemMoniker(L"!", wsz, getter_AddRefs(moniker));  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);  hr = runningObjectTable->Register(ROTFLAGS_REGISTRATIONKEEPSALIVE,                                    aUnkGraph,                                    moniker,                                    aOutRotRegister);  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);  return S_OK;}

// Removes a filter graph from the Running Object Tablevoid CTsReaderFilter::RemoveGraphFromRot(){  if (m_dwGraphRegister==0) return;  CComPtr <IRunningObjectTable> pROT;  if (SUCCEEDED(GetRunningObjectTable(0, &pROT)))      pROT->Revoke(m_dwGraphRegister);}

void RemoveFromRot(DWORD pdwRegister){	IRunningObjectTable *pROT;    if (SUCCEEDED(GetRunningObjectTable(0, &pROT))) {        pROT->Revoke(pdwRegister);        pROT->Release();    }}

voidRemoveGraphFromRunningObjectTable(DWORD aRotRegister){  nsRefPtr<IRunningObjectTable> runningObjectTable;  if (SUCCEEDED(GetRunningObjectTable(0, getter_AddRefs(runningObjectTable)))) {    runningObjectTable->Revoke(aRotRegister);  }}

//-----------------------------------------------------------------------------// RemoveGraphFromRot// Removes a filter graph from the Running Object Tablevoid CDSUtils::RemoveGraphFromRot(DWORD pdwRegister){    CComPtr<IRunningObjectTable> pROT = NULL;    if (SUCCEEDED(GetRunningObjectTable(0, &pROT)))    {        pROT->Revoke(pdwRegister);    }}

void CDShowControl::RemoveGraphFromRot(DWORD pRegister){	IRunningObjectTable *pRot;	if(SUCCEEDED(GetRunningObjectTable(0, &pRot)))	{		pRot->Revoke(pRegister);		pRot->Release();	}}

static HRESULTRegisterInterp(    const char *name,    RegisteredInterp *riPtr){    HRESULT hr = S_OK;    LPRUNNINGOBJECTTABLE pROT = NULL;    LPMONIKER pmk = NULL;    int i, offset;    const char *actualName = name;    Tcl_DString dString;    Tcl_DStringInit(&dString);    hr = GetRunningObjectTable(0, &pROT);    if (SUCCEEDED(hr)) {	offset = 0;	for (i = 1; SUCCEEDED(hr); i++) {	    if (i > 1) {		if (i == 2) {		    Tcl_DStringInit(&dString);		    Tcl_DStringAppend(&dString, name, -1);		    Tcl_DStringAppend(&dString, " #", 2);		    offset = Tcl_DStringLength(&dString);		    Tcl_DStringSetLength(&dString, offset+TCL_INTEGER_SPACE);		    actualName = Tcl_DStringValue(&dString);		}		sprintf(Tcl_DStringValue(&dString) + offset, "%d", i);	    }	    hr = BuildMoniker(actualName, &pmk);	    if (SUCCEEDED(hr)) {		hr = pROT->lpVtbl->Register(pROT,		    ROTFLAGS_REGISTRATIONKEEPSALIVE,		    riPtr->obj, pmk, &riPtr->cookie);		pmk->lpVtbl->Release(pmk);	    }	    if (hr == MK_S_MONIKERALREADYREGISTERED) {		pROT->lpVtbl->Revoke(pROT, riPtr->cookie);	    } else if (hr == S_OK) {		break;	    }	}	pROT->lpVtbl->Release(pROT);    }    if (SUCCEEDED(hr)) {	riPtr->name = strdup(actualName);    }    Tcl_DStringFree(&dString);    return hr;}

// Removes a filter graph from the Running Object Tablevoid CBDAFilterGraph::RemoveGraphFromRot(        DWORD pdwRegister        ){    CComPtr <IRunningObjectTable> pROT;    if (SUCCEEDED(GetRunningObjectTable(0, &pROT)))         pROT->Revoke(pdwRegister);}

// Removes a filter graph from the Running Object Tablevoid __fastcall RemoveGraphFromRot(DWORD dwRegister){	IRunningObjectTable *pROT;	if(SUCCEEDED(GetRunningObjectTable(0, &pROT)))	{		pROT->Revoke(dwRegister);		pROT->Release();	}}

//Приватная функция. Удаляет текущий граф из ROT (Running Object Table)void CDirectShow::RemoveFGFromROT(){	IRunningObjectTable *pRunningObjectTable = NULL;    if (SUCCEEDED(GetRunningObjectTable(0, &pRunningObjectTable)))	{        pRunningObjectTable->Revoke(m_dwROTRegister);        pRunningObjectTable->Release();		m_dwROTRegister = 0;    }}

void CDXGraph::RemoveFromObjectTable(void){	IRunningObjectTable * objectTable = 0;    if (SUCCEEDED(GetRunningObjectTable(0, &objectTable))) 	{        objectTable->Revoke(mObjectTableEntry);        objectTable->Release();		mObjectTableEntry = 0;    }}

static NTSTATUS EnumRunningObjectTable(    _In_ PVOID ThreadParam    ){    IRunningObjectTable* iRunningObjectTable = NULL;    IEnumMoniker* iEnumMoniker = NULL;    IMoniker* iMoniker = NULL;    IBindCtx* iBindCtx = NULL;    IMalloc* iMalloc = NULL;    ULONG count = 0;    HWND listViewHandle = (HWND)ThreadParam;    if (!SUCCEEDED(CoGetMalloc(1, &iMalloc)))        return STATUS_INSUFFICIENT_RESOURCES;    // Query the running object table address    if (SUCCEEDED(GetRunningObjectTable(0, &iRunningObjectTable)))    {        // Enum the objects registered        if (SUCCEEDED(IRunningObjectTable_EnumRunning(iRunningObjectTable, &iEnumMoniker)))        {            while (IEnumMoniker_Next(iEnumMoniker, 1, &iMoniker, &count) == S_OK)            {                if (SUCCEEDED(CreateBindCtx(0, &iBindCtx)))                {                    OLECHAR* displayName = NULL;                    // Query the object name                    if (SUCCEEDED(IMoniker_GetDisplayName(iMoniker, iBindCtx, NULL, &displayName)))                    {                        // Set the items name column                        PhAddListViewItem(listViewHandle, MAXINT, displayName, NULL);                        // Free the object name                        IMalloc_Free(iMalloc, displayName);                    }                    IBindCtx_Release(iBindCtx);                }                IEnumMoniker_Release(iMoniker);            }            IEnumMoniker_Release(iEnumMoniker);        }        IRunningObjectTable_Release(iRunningObjectTable);    }    IMalloc_Release(iMalloc);    return STATUS_SUCCESS;}

// Function name	: CVMR9Graph::RemoveFromRot// Description	    : remove the graph instance accessibility from graphedit// Return type		: void void CVMR9Graph::RemoveFromRot(){	if (m_dwRotId != -1) {		IRunningObjectTable *pROT;		if (SUCCEEDED(GetRunningObjectTable(0, &pROT))) {			pROT->Revoke(m_dwRotId);			m_dwRotId = -1;			pROT->Release();		}	}}

/** Accesses the correct visual studio instance if possible. */bool AccessVisualStudio(CComPtr<EnvDTE::_DTE>& OutDTE, const FString& InSolutionPath, const TArray<FVSAccessorModule::VisualStudioLocation>& InLocations){	bool bSuccess = false;	// Open the Running Object Table (ROT)	IRunningObjectTable* RunningObjectTable;	if (SUCCEEDED(GetRunningObjectTable(0, &RunningObjectTable)) &&		RunningObjectTable)	{		IEnumMoniker* MonikersTable;		RunningObjectTable->EnumRunning(&MonikersTable);		MonikersTable->Reset();		// Look for all visual studio instances in the ROT		IMoniker* CurrentMoniker;		while (!bSuccess && MonikersTable->Next(1, &CurrentMoniker, NULL) == S_OK)		{			IBindCtx* BindContext;			LPOLESTR OutName;			CComPtr<IUnknown> ComObject;			if (SUCCEEDED(CreateBindCtx(0, &BindContext)) &&				SUCCEEDED(CurrentMoniker->GetDisplayName(BindContext, NULL, &OutName)) &&				IsVisualStudioMoniker(FString(OutName), InLocations) &&				SUCCEEDED(RunningObjectTable->GetObject(CurrentMoniker, &ComObject)))			{				CComPtr<EnvDTE::_DTE> TempDTE;				TempDTE = ComObject;								// Get the solution path for this instance				// If it equals the solution we would have opened above in RunVisualStudio(), we'll take that				CComPtr<EnvDTE::_Solution> Solution;				LPOLESTR OutPath;				if (SUCCEEDED(TempDTE->get_Solution(&Solution)) &&					SUCCEEDED(Solution->get_FullName(&OutPath)))				{					FString Filename(OutPath);					FPaths::NormalizeFilename(Filename);					if( Filename == InSolutionPath )					{						OutDTE = TempDTE;						bSuccess = true;					}				}			}			BindContext->Release();			CurrentMoniker->Release();		}		MonikersTable->Release();		RunningObjectTable->Release();	}	return bSuccess;}

/****************************************************************************** *        BindCtx_GetRunningObjectTable ******************************************************************************/static HRESULT WINAPIBindCtxImpl_GetRunningObjectTable(IBindCtx* iface,IRunningObjectTable** pprot){    BindCtxImpl *This = impl_from_IBindCtx(iface);    TRACE("(%p,%p)/n",This,pprot);    if (pprot==NULL)        return E_POINTER;    return GetRunningObjectTable(0, pprot);}

/*********************************************************************** *		RevokeActiveObject (OLEAUT32.34) * * Revokes an object from the global item table. * * PARAMS *  xregister [I] Registration cookie. *  reserved  [I] Reserved. Set to NULL. * * RETURNS *  Success: S_OK. *  Failure: HRESULT code. */HRESULT WINAPI RevokeActiveObject(DWORD xregister,LPVOID reserved){	LPRUNNINGOBJECTTABLE	runobtable;	HRESULT			ret;	ret = GetRunningObjectTable(0,&runobtable);	if (FAILED(ret)) return ret;	ret = IRunningObjectTable_Revoke(runobtable,xregister);	if (SUCCEEDED(ret)) ret = S_OK;	IRunningObjectTable_Release(runobtable);	return ret;}

IFileIsInUse* CreateIFileIsInUse(const string& File){	IFileIsInUse *pfiu = nullptr;	IRunningObjectTable *prot;	if (SUCCEEDED(GetRunningObjectTable(0, &prot)))	{		IMoniker *pmkFile;		if (SUCCEEDED(CreateFileMoniker(File.data(), &pmkFile)))		{			IEnumMoniker *penumMk;			if (SUCCEEDED(prot->EnumRunning(&penumMk)))			{				HRESULT hr = E_FAIL;				ULONG celt;				IMoniker *pmk;				while (FAILED(hr) && (penumMk->Next(1, &pmk, &celt) == S_OK))				{					DWORD dwType;					if (SUCCEEDED(pmk->IsSystemMoniker(&dwType)) && dwType == MKSYS_FILEMONIKER)					{						IMoniker *pmkPrefix;						if (SUCCEEDED(pmkFile->CommonPrefixWith(pmk, &pmkPrefix)))						{							if (pmkFile->IsEqual(pmkPrefix) == S_OK)							{								IUnknown *punk;								if (prot->GetObject(pmk, &punk) == S_OK)								{									hr = punk->QueryInterface(#ifdef __GNUC__										IID_IFileIsInUse, IID_PPV_ARGS_Helper(&pfiu)#else										IID_PPV_ARGS(&pfiu)#endif										);									punk->Release();								}							}							pmkPrefix->Release();						}					}					pmk->Release();				}				penumMk->Release();			}			pmkFile->Release();		}		prot->Release();	}	return pfiu;}

static intFindInterpreterObject(    Tcl_Interp *interp,    const char *name,    LPDISPATCH *ppdisp){    LPRUNNINGOBJECTTABLE pROT = NULL;    int result = TCL_OK;    HRESULT hr = GetRunningObjectTable(0, &pROT);    if (SUCCEEDED(hr)) {	IBindCtx* pBindCtx = NULL;	hr = CreateBindCtx(0, &pBindCtx);	if (SUCCEEDED(hr)) {	    LPMONIKER pmk = NULL;	    hr = BuildMoniker(name, &pmk);	    if (SUCCEEDED(hr)) {		IUnknown *pUnkInterp = NULL, **ppUnkInterp = &pUnkInterp;		hr = pROT->lpVtbl->IsRunning(pROT, pmk);		hr = pmk->lpVtbl->BindToObject(pmk, pBindCtx, NULL,			&IID_IUnknown, (void **) ppUnkInterp);		if (SUCCEEDED(hr)) {		    hr = pUnkInterp->lpVtbl->QueryInterface(pUnkInterp,			    &IID_IDispatch, (void **) ppdisp);		    pUnkInterp->lpVtbl->Release(pUnkInterp);		} else {		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(			    "no application named /"%s/"", name));		    Tcl_SetErrorCode(interp, "TK", "LOOKUP", "APPLICATION",			    NULL);		    result = TCL_ERROR;		}		pmk->lpVtbl->Release(pmk);	    }	    pBindCtx->lpVtbl->Release(pBindCtx);	}	pROT->lpVtbl->Release(pROT);    }    if (FAILED(hr) && result == TCL_OK) {	Tcl_SetObjResult(interp, Win32ErrorObj(hr));	result = TCL_ERROR;    }    return result;}

// register in the running object table for graph debuggingSTDMETHODIMP BridgeSource::JoinFilterGraph(IFilterGraph * pGraph, LPCWSTR pName){    HRESULT hr = CBaseFilter::JoinFilterGraph(pGraph, pName);    // for debugging, we register in the ROT so that you can use    // Graphedt's Connect command to view the graphs    // disabled by default owing to refcount leak issue    if (false) //SUCCEEDED(hr))    {        if (pGraph == NULL)        {            if (m_dwROT) {                IRunningObjectTablePtr pROT;                if (SUCCEEDED(GetRunningObjectTable(0, &pROT))) {                    pROT->Revoke(m_dwROT);                }            }        } else {            IMonikerPtr pMoniker;            IRunningObjectTablePtr pROT;            if (SUCCEEDED(GetRunningObjectTable(0, &pROT))) {				ostringstream strm;				DWORD graphaddress = (DWORD)((DWORD_PTR)(IUnknown*)pGraph) & 0xFFFFFFFF;				strm << "FilterGraph " << hex << graphaddress << " pid " << hex << GetCurrentProcessId();				_bstr_t strName = strm.str().c_str();                HRESULT hr = CreateItemMoniker(L"!", strName, &pMoniker);                if (SUCCEEDED(hr)) {                    hr = pROT->Register(0, pGraph, pMoniker, &m_dwROT);                }            }        }    }    return hr;}

static HRESULT WINAPI IHlinkBC_Revoke(IHlinkBrowseContext* iface,        DWORD dwRegister){    HRESULT r = S_OK;    IRunningObjectTable *ROT;    HlinkBCImpl  *This = (HlinkBCImpl*)iface;    FIXME("(%p)->(%li)/n", This, dwRegister);    GetRunningObjectTable(0, &ROT);    r = IRunningObjectTable_Revoke(ROT, dwRegister);    IRunningObjectTable_Release(ROT);    return r;}

//////////////////////// For GraphEdit Dubug purpose /////////////////////////////void CDXGraph::AddToObjectTable(void){	IMoniker * pMoniker = 0;    IRunningObjectTable * objectTable = 0;    if (SUCCEEDED(GetRunningObjectTable(0, &objectTable))) 	{		WCHAR wsz[256];		wsprintfW(wsz, L"FilterGraph %08p pid %08x", (DWORD_PTR)mGraph, GetCurrentProcessId());		HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);		if (SUCCEEDED(hr)) 		{			hr = objectTable->Register(0, mGraph, pMoniker, &mObjectTableEntry);			pMoniker->Release();		}		objectTable->Release();	}}

HRESULT AddGraphToRot(IUnknown *pUnkGraph, DWORD *pdwRegister){    IMoniker * pMoniker;    IRunningObjectTable *pROT;    if (FAILED(GetRunningObjectTable(0, &pROT))) {        return E_FAIL;    }    WCHAR wsz[128];    wsprintfW(wsz, L"FilterGraph %08x pid %08x", (DWORD_PTR)pUnkGraph, GetCurrentProcessId());    HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);    if (SUCCEEDED(hr)) {        hr = pROT->Register(0, pUnkGraph, pMoniker, pdwRegister);        pMoniker->Release();    }    pROT->Release();    return hr;}

static bool GetFilterGraph(IFilterGraph** ppFG){	if(!ppFG) return(false);    CComPtr<IRunningObjectTable> pROT;    if(FAILED(GetRunningObjectTable(0, &pROT)))		return 1;	CComPtr<IEnumMoniker> pEM;	if(FAILED(pROT->EnumRunning(&pEM)))		return 1;	CComPtr<IBindCtx> pBindCtx;	CreateBindCtx(0, &pBindCtx);	for(CComPtr<IMoniker> pMoniker; S_OK == pEM->Next(1, &pMoniker, NULL); pMoniker = NULL)	{		LPOLESTR pDispName = NULL;		if(FAILED(pMoniker->GetDisplayName(pBindCtx, NULL, &pDispName)))			continue;		CStringW strw(pDispName);				CComPtr<IMalloc> pMalloc;		if(FAILED(CoGetMalloc(1, &pMalloc)))			continue;		pMalloc->Free(pDispName);		if(strw.Find(L"(MPC)") < 0)			continue;		CComPtr<IUnknown> pUnk;		if(S_OK != pROT->GetObject(pMoniker, &pUnk))			continue;		CComQIPtr<IFilterGraph> pFG = pUnk;		if(!pFG)			continue;		*ppFG = pFG.Detach();		break;	}	return(!!*ppFG);}

void COleLinkingDoc::Revoke(){	ASSERT_VALID(this);	// revoke current registration	if (m_dwRegister != 0)	{		LPRUNNINGOBJECTTABLE lpROT = NULL;		GetRunningObjectTable(0, &lpROT);		if (lpROT != NULL)		{			lpROT->Revoke(m_dwRegister);			lpROT->Release();		}		m_dwRegister = 0;	}	RELEASE(m_lpMonikerROT);	m_strMoniker = _T("");}

HRESULT CTsReaderFilter::AddGraphToRot(IUnknown *pUnkGraph){  CComPtr <IMoniker>              pMoniker;  CComPtr <IRunningObjectTable>   pROT;  WCHAR wsz[128];  HRESULT hr;  if (m_dwGraphRegister!=0) return S_OK;  if (FAILED(GetRunningObjectTable(0, &pROT)))      return E_FAIL;  swprintf(wsz, L"FilterGraph %08x pid %08x/0", (DWORD_PTR) pUnkGraph, GetCurrentProcessId());  hr = CreateItemMoniker(L"!", wsz, &pMoniker);  if (SUCCEEDED(hr))  {    hr = pROT->Register(ROTFLAGS_REGISTRATIONKEEPSALIVE, pUnkGraph, pMoniker, &m_dwGraphRegister);  }  return hr;}

//Добавляет текущий Filter Graph в ROT (Running Object Table)//В случае ошибки функция вернет значение меньше нуляint CDirectShow::AddFGToROT(){	if (m_pGraphBuilder)	{		IMoniker *pMoniker = NULL;		IRunningObjectTable *pRunningObjectTable = NULL;		if (FAILED(GetRunningObjectTable(0, &pRunningObjectTable)))		{			return -1;		}		WCHAR lpwItem[256] = { 0 };		swprintf(lpwItem, L"FilterGraph %08p pid %08x", (LPDWORD)m_pGraphBuilder, GetCurrentProcessId());		if (FAILED(CreateItemMoniker(L"!", lpwItem, &pMoniker))) return -1;		pRunningObjectTable->Register(0, m_pGraphBuilder, pMoniker, &m_dwROTRegister);		pMoniker->Release();		pRunningObjectTable->Release();		return 0;	}	else return -1;}