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 void
RevokeObjectRegistration(
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;
}
HRESULT
AddGraphToRunningObjectTable(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 Table
void 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();
}
}
void
RemoveGraphFromRunningObjectTable(DWORD aRotRegister)
{
nsRefPtr<IRunningObjectTable> runningObjectTable;
if (SUCCEEDED(GetRunningObjectTable(0, getter_AddRefs(runningObjectTable)))) {
runningObjectTable->Revoke(aRotRegister);
}
}
//-----------------------------------------------------------------------------
// RemoveGraphFromRot
// Removes a filter graph from the Running Object Table
void 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 HRESULT
RegisterInterp(
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 Table
void CBDAFilterGraph::RemoveGraphFromRot(
DWORD pdwRegister
)
{
CComPtr <IRunningObjectTable> pROT;
if (SUCCEEDED(GetRunningObjectTable(0, &pROT)))
pROT->Revoke(pdwRegister);
}
// Removes a filter graph from the Running Object Table
void __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 WINAPI
BindCtxImpl_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 int
FindInterpreterObject(
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 debugging
STDMETHODIMP
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;
}
