static void test_ProgIDFromCLSID(void) { LPWSTR progid; HRESULT hr = ProgIDFromCLSID(&CLSID_CDeviceMoniker, &progid); ok(hr == S_OK, "ProgIDFromCLSID failed with error 0x%08lx\n", hr); if (hr == S_OK) { ok(!lstrcmpiW(progid, devicedotone), "Didn't get expected prog ID\n"); CoTaskMemFree(progid); } progid = (LPWSTR)0xdeadbeef; hr = ProgIDFromCLSID(&CLSID_non_existent, &progid); ok(hr == REGDB_E_CLASSNOTREG, "ProgIDFromCLSID returned %08lx\n", hr); ok(progid == NULL, "ProgIDFromCLSID returns with progid %p\n", progid); }
// // CLSIDToString // Mostly for debugging purposes (TRACE et al) // HRESULT CLSIDToString(REFCLSID rclsid, LPTSTR ptzBuffer, size_t cchBuffer) { ASSERT(NULL != ptzBuffer); ASSERT(0 != cchBuffer); LPOLESTR pOleString = NULL; HRESULT hr = ProgIDFromCLSID(rclsid, &pOleString); if (FAILED(hr)) { hr = StringFromCLSID(rclsid, &pOleString); } if (SUCCEEDED(hr) && pOleString) { #if defined(UNICODE) hr = StringCchCopy(ptzBuffer, cchBuffer, pOleString); #else // UNICODE int nReturn = WideCharToMultiByte(CP_ACP, 0, pOleString, (int)wcslen(pOleString), ptzBuffer, (int)cchBuffer, NULL, NULL); if (nReturn == 0) { hr = HrGetLastError(); } #endif } CoTaskMemFree(pOleString); return hr; }
STDMETHODIMP CProviderInfo::get_Provider (enum ProviderRole Type,BSTR * pProgID ) { if(!pProgID) return E_POINTER; if(*pProgID) SysFreeString(*pProgID); HRESULT hr = S_OK; CLSID clType= GUID_NULL; switch(Type) { case enBatchPriceInfo: { clType = __uuidof( DataFeedBatchPriceInfo ); break; } case enStructureProviderEx: { clType = __uuidof( DataFeedStructureInfo); break; } } BSTR bsData; hr = ProgIDFromCLSID(clType, &bsData); if(SUCCEEDED(hr)) *pProgID = SysAllocString((BSTR)bsData); else *pProgID = SysAllocString(L""); return hr; }
/** *\fn std::string CLSIDToProgID(const char *clsid) *\brief 将CLSID转成类名,CLSID例:{2D7E0F8F-3215-11D0-BF28-0000E8D0D146} *\param[in] const char * clsid *\return std::string 类名 */ std::string CAddinProcess::CLSIDToProgID(const char *clsid) { if (NULL == clsid) return ""; USES_CONVERSION; CLSID clsid_data = {0}; OLECHAR clsid_wstr[100] = {0}; LPOLESTR prog_id = NULL; wcscpy(clsid_wstr, CT2OLE(clsid)); HRESULT hr = CLSIDFromString(clsid_wstr, &clsid_data); if (FAILED(hr)) return ""; hr = ProgIDFromCLSID(clsid_data, &prog_id); if (FAILED(hr)) return ""; LPCTSTR lpstr = OLE2CT(prog_id); std::string out(lpstr); IMalloc * pMalloc = NULL; hr = ::CoGetMalloc(1, &pMalloc); // 取得 IMalloc if (SUCCEEDED(hr)) { pMalloc->Free(prog_id); // 释放ProgID内存 pMalloc->Release(); // 释放IMalloc } return out; }
HRESULT CTCPropBagOnRegKey::_SaveObject(const _bstr_t& strName, IUnknown* punkObj, BOOL bClearDirty, BOOL bSaveAllProperties) { // Validate the specified parameters if (IsBadReadPtr(punkObj)) return E_POINTER; // Create a subkey with the specified name CRegKey subkey; if (!strName.length()) subkey = m_key; else { m_key.DeleteValue(strName); m_key.RecurseDeleteKey(strName); if (!subkey.Open(m_key, strName)) return HRESULT_FROM_WIN32(GetLastError()); } // QueryInterface for IPersistPropertyBag IPersistPropertyBagPtr pppb; HRESULT hr = punkObj->QueryInterface(__uuidof(pppb), (void**)&pppb); if (FAILED(hr)) return hr; // Get the object's CLSID CLSID clsid; hr = pppb->GetClassID(&clsid); if (FAILED(hr)) return hr; // Attempt first to convert the object's CLSID to a ProgID LPOLESTR pszProgID = NULL; if (SUCCEEDED(ProgIDFromCLSID(clsid, &pszProgID))) { subkey.WriteString(m_szProgID, pszProgID); CoTaskMemFree(pszProgID); } else { // Convert the object's CLSID to a string OLECHAR szClassID[64]; StringFromGUID2(clsid, szClassID, sizeofArray(szClassID)); subkey.WriteString(m_szCLSID, szClassID); } // Write the variant type value subkey.WriteDWord(m_szVariantType, DWORD(VarTypeFromUnknown(punkObj))); // Save the persistent properties of the object CComObjectStack<CTCPropBagOnRegKey> bag; bag.Init(subkey, strName, this); hr = pppb->Save(&bag, bClearDirty, bSaveAllProperties); // Return the last HRESULT return hr; }
// IsCallbackRegistered() // Determine if callback interface is already registered. // Used by Register/Unregister menu item handlers. BOOL CEventHandlerApp::IsCallbackRegistered() { LPOLESTR lpszProgID = NULL; HRESULT hr = ProgIDFromCLSID( CLSID_QBSDKCallback, &lpszProgID ); if( lpszProgID ) { CoTaskMemFree( lpszProgID ); lpszProgID = NULL; } return SUCCEEDED(hr); }
HRESULT CExeModule::UnregisterServer(BOOL bUnRegTypeLib, const CLSID* pCLSID) { CComPtr<ICatRegister> spcr; HRESULT hr = spcr.CoCreateInstance(CLSID_StdComponentCategoriesMgr, NULL, CLSCTX_INPROC); if(SUCCEEDED(hr) && spcr!=NULL) { CATID catid = CATID_PriceProviders; CComBSTR bs; ProgIDFromCLSID(CLSID_ProviderInfo, &bs); spcr->UnRegisterClassImplCategories( CLSID_ProviderInfo, 1, &catid); } return CComModule::UnregisterServer(bUnRegTypeLib, pCLSID); }
STDMETHODIMP CProviderInfo::get_Provider(ProviderRole type, BSTR *pProgID) { if(!pProgID) return E_POINTER; if(*pProgID) SysFreeString(*pProgID); HRESULT hr = S_OK; CLSID clType= GUID_NULL; switch(type) { // case enStructureProvider: // clType = CLSID_HyperFeedStructureProvider; // break; case enBatchPriceInfo: clType = __uuidof( ActivFeedBatchPriceInfo ); break; case enStructureProviderEx: clType = __uuidof(ActivFeedStructureInfo); break; // case enPriceProvider: // clType = CLSID_HyperFeedPriceProvider; // break; // case enPriceInfo: // clType = CLSID_HyperFeedPriceInfo; // break; // case enPriceInfoWithNotify: // clType = CLSID_HyperFeedPriceInfoWithNotify; // break; // case enBatchPriceInfo: // clType = CLSID_HyperFeedBatchPriceInfo; // break; // case enStructureProviderEx: // clType = CLSID_HyperFeedStructureProviderEx; // break; } BSTR bsData; hr = ProgIDFromCLSID(clType, &bsData); if(SUCCEEDED(hr)) *pProgID = SysAllocString((BSTR)bsData); else *pProgID = SysAllocString(L""); return hr; }
/****************************************************************************** * ProgIDFromCLSID [COMPOBJ.62] * * Converts a class id into the respective Program ID. (By using a registry lookup) * * RETURNS * S_OK on success * riid associated with the progid */ HRESULT WINAPI ProgIDFromCLSID16( REFCLSID clsid, /* [in] class id as found in registry */ LPOLESTR16 *lplpszProgID )/* [out] associated Program ID */ { LPOLESTR progid; HRESULT ret; ret = ProgIDFromCLSID( clsid, &progid ); if (ret == S_OK) { INT len = WideCharToMultiByte( CP_ACP, 0, progid, -1, NULL, 0, NULL, NULL ); ret = _xmalloc16(len, (SEGPTR*)lplpszProgID); if (ret == S_OK) WideCharToMultiByte( CP_ACP, 0, progid, -1, MapSL((SEGPTR)*lplpszProgID), len, NULL, NULL ); CoTaskMemFree( progid ); } return ret; }
static VALUE ole_type_progid(ITypeInfo *pTypeInfo) { HRESULT hr; TYPEATTR *pTypeAttr; OLECHAR *pbuf; VALUE progid = Qnil; hr = OLE_GET_TYPEATTR(pTypeInfo, &pTypeAttr); if (FAILED(hr)) return progid; hr = ProgIDFromCLSID(&pTypeAttr->guid, &pbuf); if (SUCCEEDED(hr)) { progid = ole_wc2vstr(pbuf, FALSE); CoTaskMemFree(pbuf); } OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr); return progid; }
//============================================================================= // 函数名称: 判断控件是否已安装 // 作者说明: mushuai // 修改时间: 2010-03-08 //============================================================================= int IsOcxInstalled(const CString& id) { int res=0; CLSID clsid; //check id is CLSID HRESULT hr = CLSIDFromString(CComBSTR(id),&clsid); if (SUCCEEDED(hr)) { LPOLESTR progid=0; hr = ProgIDFromCLSID(clsid,&progid); if (SUCCEEDED(hr)) { res=1; } else { if (hr == REGDB_E_CLASSNOTREG) { res=0; } else { res=-1; } } } else { hr = CLSIDFromProgID(CComBSTR(id),&clsid); if (SUCCEEDED(hr)) { res=1; } else if(hr ==REGDB_E_CLASSNOTREG || hr==CO_E_CLASSSTRING) { res = 0; } else { res = -1; } } return res; }
HRESULT PASCAL CComObjectRoot::Error(const CLSID& clsid, LPCOLESTR lpszDesc, const IID& iid, HRESULT hRes) { CComPtr<ICreateErrorInfo> pICEI; if (SUCCEEDED(CreateErrorInfo(&pICEI))) { CComPtr<IErrorInfo> pErrorInfo; pICEI->SetGUID(iid); LPOLESTR lpsz; ProgIDFromCLSID(clsid, &lpsz); if (lpsz != NULL) pICEI->SetSource(lpsz); CoTaskMemFree(lpsz); pICEI->SetDescription((LPOLESTR)lpszDesc); if (SUCCEEDED(pICEI->QueryInterface(IID_IErrorInfo, (void**)&pErrorInfo))) SetErrorInfo(0, pErrorInfo); } return (hRes == 0) ? DISP_E_EXCEPTION : hRes; }
HRESULT ComErrorInfo(const CLSID& clsid, REFIID riid, IErrorInfo ** ppErrInfo, LPCTSTR pszDesc) { USES_CONVERSION; ICreateErrorInfo* pcei = NULL; IErrorInfo * pei = NULL; LPOLESTR lpsz; if(ppErrInfo == NULL) { return E_POINTER; } *ppErrInfo = NULL; if(clsid == CLSID_NULL) { return S_FALSE; } HRESULT hr = CreateErrorInfo(&pcei); if(FAILED(hr)) { return hr; } ProgIDFromCLSID(clsid, &lpsz); if (lpsz != NULL) { pcei->SetSource(lpsz); ::CoTaskMemFree(lpsz); } lpsz = T2OLE(pszDesc); pcei->SetDescription(lpsz); //Interface ID of the interface whose method is throwing the Except. pcei->SetGUID(riid); hr = pcei->QueryInterface(IID_IErrorInfo, (void**) &pei); if(SUCCEEDED(hr)) { *ppErrInfo = pei; } pcei->Release(); return hr; }
//* void local_host::get_clsid( const CATID& cat_id, LPCOLESTR server_name, CLSID& server_id ) { #if defined _DEBUG && defined _CONSOLE wprintf( L"get_clsid( %s )\n", server_name ); #endif CATID Implist[1] = { cat_id }; ATL::CComPtr<IEnumCLSID> iEnum; HRESULT result = root_->EnumClassesOfCategories(1, Implist,0, NULL, &iEnum); if (FAILED(result)) { throw opc_exception( result, OLESTR("Failed to get enum for categeories") ); } GUID glist; ULONG actual; while((result = iEnum->Next(1, &glist, &actual)) == S_OK) { cotask_holder<OLECHAR> progID; HRESULT res = ProgIDFromCLSID(glist, progID.addr()); if(FAILED(res)) { throw opc_exception( res, OLESTR("Failed to get ProgId from ClassId") ); } else { #if defined _DEBUG && defined _CONSOLE wprintf( L"progId = %s\n", progID ); #endif if ( lstrcmpW( progID.get(), server_name ) == 0 ) { server_id = glist; return; } } } }
STDMETHODIMP CProviderInfo::get_Provider(ProviderRole type, BSTR *pProgID) { if(!pProgID) return E_POINTER; HRESULT hr =S_OK; CLSID clType= GUID_NULL; switch(type) { case enStructureProvider: clType = CLSID_ATFStructureProvider; break; case enStructureInfo: clType = CLSID_ATFStructureInfo; break; case enPriceProvider: clType = CLSID_ATFPriceProvider; break; case enPriceInfo: clType = CLSID_ATFPriceInfo; break; case enPriceInfoWithNotify: clType = CLSID_ATFPriceInfoWithNotify; break; } BSTR bsData; hr = ProgIDFromCLSID(clType, &bsData); if(SUCCEEDED(hr)) *pProgID = ::SysAllocString(bsData); else *pProgID = ::SysAllocString(L""); return hr; }
HRESULT primProgIDFromCLSID( const CLSID* clsid, WCHAR** clsidStr ) { if (!clsid) clsid = &IID_NULL; if (clsidStr) return ProgIDFromCLSID( clsid, clsidStr ); else return E_POINTER; }
/// \param[in] configSection @copydoc initArg1 /// \param[in] configFile @copydoc initArg2 /// \param[in] host @copydoc initArg3 /// \param[in] options @copydoc initArg4 /// \param[in] progid @copydoc initArg5 /// \param[in] username @copydoc initArg6 /// \param[in] password @copydoc initArg7 lvDCOMInterface::lvDCOMInterface(const char *configSection, const char* configFile, const char* host, int options, const char* progid, const char* username, const char* password) : m_configSection(configSection), m_pidentity(NULL), m_pxmldom(NULL), m_options(options), m_progid(progid != NULL? progid : ""), m_username(username != NULL? username : ""), m_password(password != NULL ? password : ""), m_mac_env(NULL) { epicsThreadOnce(&onceId, initCOM, NULL); if (host != NULL && host[0] != '\0') { m_host = host; } else { // char name_buffer[MAX_COMPUTERNAME_LENGTH + 1]; // DWORD name_size = MAX_COMPUTERNAME_LENGTH + 1; // if ( GetComputerNameEx(ComputerNameNetBIOS, name_buffer, &name_size) != 0 ) // { // m_host = name_buffer; // } // else // { // m_host = "localhost"; // } m_host = "localhost"; } if (macCreateHandle(&m_mac_env, NULL) != 0) { throw std::runtime_error("Cannot create mac handle"); } // load current environment into m_mac_env, this is so we can create a macEnvExpand() equivalent // but tied to the environment at a specific time. It is useful if we want to load the same // XML file twice but with a macro defined differently in each case for(char** cp = environ; *cp != NULL; ++cp) { char* str_tmp = strdup(*cp); char* equals_loc = strchr(str_tmp, '='); // split name=value string if (equals_loc != NULL) { *equals_loc = '\0'; macPutValue(m_mac_env, str_tmp, equals_loc + 1); } free(str_tmp); } // m_doc = new TiXmlDocument; // if ( !m_doc->LoadFile(configFile) ) // { // delete m_doc; // m_doc = NULL; // throw std::runtime_error("Cannot load " + std::string(configFile) + ": load failure"); // } // m_root = m_doc->RootElement(); DomFromCOM(); short sResult = FALSE; char* configFile_expanded = envExpand(configFile); m_configFile = configFile_expanded; HRESULT hr = m_pxmldom->load(_variant_t(configFile_expanded), &sResult); free(configFile_expanded); if(FAILED(hr)) { throw std::runtime_error("Cannot load XML \"" + m_configFile + "\" (expanded from \"" + std::string(configFile) + "\"): load failure"); } if (sResult != VARIANT_TRUE) { throw std::runtime_error("Cannot load XML \"" + m_configFile + "\" (expanded from \"" + std::string(configFile) + "\"): load failure"); } std::cerr << "Loaded XML config file \"" << m_configFile << "\" (expanded from \"" << configFile << "\")" << std::endl; m_extint = doPath("/lvinput/extint/@path").c_str(); epicsAtExit(epicsExitFunc, this); if (m_progid.size() > 0) { if ( CLSIDFromProgID(CT2W(m_progid.c_str()), &m_clsid) != S_OK ) { throw std::runtime_error("Cannot find progId " + m_progid); } } else { m_clsid = LabVIEW::CLSID_Application; wchar_t* progid_str = NULL; if ( ProgIDFromCLSID(m_clsid, &progid_str) == S_OK ) { m_progid = CW2CT(progid_str); CoTaskMemFree(progid_str); } else { m_progid = "LabVIEW.Application"; } } wchar_t* clsid_str = NULL; if ( StringFromCLSID(m_clsid, &clsid_str) == S_OK ) { std::cerr << "Using ProgID \"" << m_progid << "\" CLSID " << CW2CT(clsid_str) << std::endl; CoTaskMemFree(clsid_str); } else { std::cerr << "Using ProgID \"" << m_progid << "\" but StringFromCLSID() failed" << std::endl; } }
static HRESULT WINAPI datainit_GetInitializationString(IDataInitialize *iface, IUnknown *datasource, boolean include_pass, LPWSTR *init_string) { static const WCHAR provW[] = {'P','r','o','v','i','d','e','r','=',0}; static const WCHAR colW[] = {';',0}; datainit *This = impl_from_IDataInitialize(iface); DBPROPINFOSET *propinfoset; IDBProperties *props; DBPROPIDSET propidset; ULONG count, infocount; WCHAR *progid, *desc; DBPROPSET *propset; IPersist *persist; HRESULT hr; CLSID clsid; int i, len; TRACE("(%p)->(%p %d %p)\n", This, datasource, include_pass, init_string); /* IPersist support is mandatory for data sources */ hr = IUnknown_QueryInterface(datasource, &IID_IPersist, (void**)&persist); if (FAILED(hr)) return hr; memset(&clsid, 0, sizeof(clsid)); hr = IPersist_GetClassID(persist, &clsid); IPersist_Release(persist); if (FAILED(hr)) return hr; progid = NULL; ProgIDFromCLSID(&clsid, &progid); TRACE("clsid=%s, progid=%s\n", debugstr_guid(&clsid), debugstr_w(progid)); /* now get initialization properties */ hr = IUnknown_QueryInterface(datasource, &IID_IDBProperties, (void**)&props); if (FAILED(hr)) { WARN("IDBProperties not supported\n"); CoTaskMemFree(progid); return hr; } propidset.rgPropertyIDs = NULL; propidset.cPropertyIDs = 0; propidset.guidPropertySet = DBPROPSET_DBINIT; propset = NULL; count = 0; hr = IDBProperties_GetProperties(props, 1, &propidset, &count, &propset); if (FAILED(hr)) { WARN("failed to get data source properties, 0x%08x\n", hr); CoTaskMemFree(progid); return hr; } infocount = 0; IDBProperties_GetPropertyInfo(props, 1, &propidset, &infocount, &propinfoset, &desc); IDBProperties_Release(props); /* check if we need to skip password */ len = strlenW(progid) + strlenW(provW) + 1; /* including ';' */ for (i = 0; i < count; i++) { WCHAR *descr = get_propinfo_descr(&propset->rgProperties[i], propinfoset); if (descr) { /* include '=' and ';' */ len += strlenW(descr) + 2; len += get_propvalue_length(&propset->rgProperties[i]); } if ((propset->rgProperties[i].dwPropertyID == DBPROP_AUTH_PERSIST_SENSITIVE_AUTHINFO) && (V_BOOL(&propset->rgProperties[i].vValue) == VARIANT_FALSE)) include_pass = FALSE; } len *= sizeof(WCHAR); *init_string = CoTaskMemAlloc(len); *init_string[0] = 0; /* provider name */ strcatW(*init_string, provW); strcatW(*init_string, progid); strcatW(*init_string, colW); CoTaskMemFree(progid); for (i = 0; i < count; i++) { WCHAR *descr; if (!include_pass && propset->rgProperties[i].dwPropertyID == DBPROP_AUTH_PASSWORD) continue; descr = get_propinfo_descr(&propset->rgProperties[i], propinfoset); if (descr) { static const WCHAR eqW[] = {'=',0}; strcatW(*init_string, descr); strcatW(*init_string, eqW); write_propvalue_str(*init_string, &propset->rgProperties[i]); strcatW(*init_string, colW); } } free_dbpropset(count, propset); free_dbpropinfoset(infocount, propinfoset); CoTaskMemFree(desc); if (!include_pass) TRACE("%s\n", debugstr_w(*init_string)); return S_OK; }
// ************************************************************************** // DisplayComponentCatList () // // Description: // Construct a list of installed 1.0 and 2.0 OPC servers and insert into // tree control. // // Parameters: // HTREEITEM hParent Handle of parent tree control item. // CATID catid Catagory ID (CATID_OPCDAServer10 or // CATID_OPCDAServer20). // // Returns: // void // ************************************************************************** void CKServerGeneralPage::DisplayComponentCatList (HTREEITEM hParent, CATID catid) { HRESULT hr; // Make sure COM is initialized: hr = CoInitializeEx (NULL, COINIT_MULTITHREADED); if (SUCCEEDED (hr)) { ICatInformation *pCat = NULL; // Get component category manager: hr = CoCreateInstance (CLSID_StdComponentCategoriesMgr, NULL, CLSCTX_SERVER, IID_ICatInformation, (void **)&pCat); // If succeeded, enumerate registered components: if (SUCCEEDED (hr)) { IEnumCLSID *pEnum = NULL; CATID arrcatid [1]; arrcatid [0] = catid; // Enumerate registered components based on clsid: hr = pCat->EnumClassesOfCategories ( sizeof (arrcatid) / sizeof (CATID), // number of catids in the array that follows arrcatid, // catid array 0, NULL, &pEnum); // clsid enumerator for registered components under this category // If succeeded, process results: if (SUCCEEDED (hr)) { GUID guid; ULONG fetched; // Loop over enumerated components. Call enemerator's next // member function to reference next component and get its // guid: while ((hr = pEnum->Next (1, &guid, &fetched)) == S_OK) { // Get the ProgID from the guid: WCHAR *wszProgID; hr = ProgIDFromCLSID (guid, &wszProgID); // If succeeded, add component to list: if (SUCCEEDED (hr)) { // ProgID string will be in UNICODE format. Convert to // ANSI format if this is and ANSI build. Insert component // into list: #ifdef _UNICODE m_pServerList->InsertItem (wszProgID, ILI_COMPONENT, ILI_COMPONENT, hParent); #else TCHAR szProgID [DEFBUFFSIZE]; _wcstombsz (szProgID, wszProgID, sizeof (szProgID) / sizeof (TCHAR)); m_pServerList->InsertItem (szProgID, ILI_COMPONENT, ILI_COMPONENT, hParent); #endif // It is up to us to free the Prog ID string memory: CoTaskMemFree (wszProgID); } } // Release our enumerator: pEnum->Release (); } // release our category mamager pCat->Release (); } // Uninitialize COM: CoUninitialize (); } }
FARINTERNAL UtContentsStmTo10NativeStm (LPSTORAGE pstg, REFCLSID rclsid, BOOL fDeleteSrcStm, UINT FAR* puiStatus) { CLIPFORMAT cf; LPOLESTR lpszUserType = NULL; HRESULT error; LPSTREAM pstmSrc = NULL; LPSTREAM pstmDst = NULL; *puiStatus = NULL; if (error = ReadFmtUserTypeStg(pstg, &cf, &lpszUserType)) return error; if (! ((cf == CF_DIB && rclsid == CLSID_PBrush) || (cf == CF_METAFILEPICT && rclsid == CLSID_MSDraw))) { error = ResultFromScode(DV_E_CLIPFORMAT); goto errRtn; } if (error = pstg->OpenStream(OLE_CONTENTS_STREAM, NULL, (STGM_READ|STGM_SHARE_EXCLUSIVE), 0, &pstmSrc)) { *puiStatus |= CONVERT_NOSOURCE; // check whether OLE10_NATIVE_STREAM exists if (pstg->OpenStream(OLE10_NATIVE_STREAM, NULL, (STGM_READ|STGM_SHARE_EXCLUSIVE), 0, &pstmDst)) *puiStatus |= CONVERT_NODESTINATION; else { pstmDst->Release(); pstmDst = NULL; } goto errRtn; } if (error = OpenOrCreateStream(pstg, OLE10_NATIVE_STREAM, &pstmDst)) { *puiStatus |= CONVERT_NODESTINATION; goto errRtn; } if (cf == CF_METAFILEPICT) error = UtPlaceableMFStmToMSDrawNativeStm(pstmSrc, pstmDst); else error = UtDIBFileStmToPBrushNativeStm(pstmSrc, pstmDst); errRtn: if (pstmDst) pstmDst->Release(); if (pstmSrc) pstmSrc->Release(); if (error == NOERROR) { LPOLESTR lpszProgId = NULL; ProgIDFromCLSID(rclsid, &lpszProgId); error = WriteFmtUserTypeStg(pstg, RegisterClipboardFormat(lpszProgId), lpszUserType); if (lpszProgId) delete lpszProgId; } if (error == NOERROR) { if (fDeleteSrcStm) pstg->DestroyElement(OLE_CONTENTS_STREAM); } else { pstg->DestroyElement(OLE10_NATIVE_STREAM); } if (lpszUserType) delete lpszUserType; return error; }