HRESULT CComModule::RegisterTypeLib() { USES_CONVERSION; _ASSERTE(m_hInst != NULL); TCHAR szModule[_MAX_PATH+4]; TCHAR szDir[_MAX_PATH]; GetModuleFileName(GetTypeLibInstance(), szModule, _MAX_PATH); CComPtr<ITypeLib> pTypeLib; HRESULT hr = LoadTypeLib(T2OLE(szModule), &pTypeLib); if (!SUCCEEDED(hr)) { // typelib not in module, try <module>.tlb instead LPTSTR lpszExt = szModule + lstrlen(szModule); for (LPTSTR lpsz = szModule; *lpsz != '\0'; lpsz = CharNext(lpsz)) { if (*lpsz == '.') lpszExt = lpsz; } _ASSERTE(lpszExt != NULL); lstrcpy(lpszExt, _T(".tlb")); hr = LoadTypeLib(T2OLE(szModule), &pTypeLib); } if (SUCCEEDED(hr)) { int nLen = lstrlen(szModule) - AtlGetFileName(szModule, NULL, 0); lstrcpy(szDir, szModule); szDir[nLen] = 0; return ::RegisterTypeLib(pTypeLib, T2OLE(szModule), T2OLE(szDir)); } return S_FALSE; }
BOOL CView::LoadPictureFile(LPCTSTR szFile) { if (m_pPicture) { m_pPicture->Release(); m_pPicture = NULL; } TRACE(szFile); TRACE("\n"); m_xCurrentScroll = 0; m_yCurrentScroll = 0; ShowScrollBar(SB_HORZ, FALSE); ShowScrollBar(SB_VERT, FALSE); // Create IPicture from image file if (S_OK == ::OleLoadPicturePath(T2OLE(szFile), NULL, 0, 0, IID_IPicture, (LPVOID *)&m_pPicture)) { CMainFrame* pFrame = GetPicApp()->GetMainFrame(); pFrame->SendMessage(UWM_FILELOADED, 0, (LPARAM)szFile); Invalidate(); return TRUE; } else { TRACE("Failed to load picture\n"); // Set Frame title back to default CMainFrame* pFrame = GetPicApp()->GetMainFrame(); pFrame->SendMessage(UWM_FILELOADED, 0, (LPARAM)LoadString(IDW_MAIN).c_str()); return FALSE; } }
bool CCOMDispatchHelper::DoesMethodExistOnInterface(const IDispatchPtr& spDisp, LPCTSTR lszMethodName) { USES_CONVERSION; DISPID rgDispId = 0; OLECHAR FAR* szMember = T2OLE(const_cast<LPTSTR>(lszMethodName)); HRESULT hr = spDisp->GetIDsOfNames(IID_NULL, &szMember, 1, LOCALE_SYSTEM_DEFAULT, &rgDispId); return (S_OK == hr && -1 != rgDispId); }
void CItemPropertiesDlg::OnRefresh() { USES_CONVERSION; CWaitCursor wait; if( m_OPCItemProps.IsOk() ) { m_list.DeleteAllItems(); DWORD numItems = 0; DWORD* pParameterIDs = NULL; LPWSTR* pDescriptions = NULL; VARTYPE* pDataTypes = NULL; HRESULT hr = m_OPCItemProps.QueryAvailableProperties(T2OLE(m_ItemID.GetBuffer(0)), &numItems, &pParameterIDs, &pDescriptions, &pDataTypes); if( SUCCEEDED(hr) ) { VARIANT* pValues = NULL; HRESULT* pErrors = NULL; hr = m_OPCItemProps.GetItemProperties(T2OLE(m_ItemID.GetBuffer(0)), numItems, pParameterIDs, &pValues, &pErrors); if( SUCCEEDED(hr) ) { LV_ITEM lvitem; for( DWORD iIndex=0; iIndex<numItems; iIndex++) { memset(&lvitem, 0, sizeof(LV_ITEM)); lvitem.mask = LVIF_TEXT; //|LVIF_IMAGE; lvitem.iItem = iIndex; lvitem.iSubItem = 0; lvitem.pszText = OLE2T(pDescriptions[iIndex]); lvitem.iImage = 2; m_list.InsertItem(&lvitem); lvitem.mask = LVIF_TEXT; lvitem.iSubItem = 1; CString text; VariantToString(pValues[iIndex], text); lvitem.pszText = (LPTSTR)(LPCTSTR)text; m_list.SetItem(&lvitem); if(pDescriptions[iIndex]) CoTaskMemFree(pDescriptions[iIndex]); if(pValues) VariantClear( &pValues[iIndex] ); } } if( pParameterIDs ) CoTaskMemFree(pParameterIDs); if( pDescriptions ) CoTaskMemFree(pDescriptions); if( pDataTypes ) CoTaskMemFree(pDataTypes); if( pValues ) CoTaskMemFree(pValues); if( pErrors ) CoTaskMemFree(pErrors); } } }
HRESULT CADsSearch::Execute( LPCTSTR pszFilter ) { USES_CONVERSION; HRESULT hr; if ( !m_pSearch ) { return E_UNEXPECTED; } m_hSearch = NULL; ////////////////////////////////////////////// // Set the search preference if any /////////////////////////////////////////////// if ( m_dwPrefCount ) { hr = m_pSearch->SetSearchPreference( m_srchInfo, m_dwPrefCount); if ( !SUCCEEDED(hr) ) { return hr; } } if ( m_sColumnList.IsEmpty() ) { hr = m_pSearch->ExecuteSearch( T2OLE(pszFilter), NULL, -1, &m_hSearch ); } else // Columns is specified { unsigned int count, xx; LPWSTR *pColumns = NULL; POSITION pos; CString s; count = m_sColumnList.GetCount(); pColumns = (LPWSTR*)AllocADsMem( sizeof(LPWSTR)*count); pos = m_sColumnList.GetHeadPosition(); for(xx=0; xx < count; xx++) { s = m_sColumnList.GetAt(pos); pColumns[xx] = T2OLE(s); m_sColumnList.GetNext(pos); } hr = m_pSearch->ExecuteSearch( T2OLE(pszFilter), pColumns, count, &m_hSearch ); if ( pColumns ) { FreeADsMem( pColumns ); } } return hr; }
BOOL AFXAPI AfxOleRegisterTypeLib(HINSTANCE hInstance, REFGUID tlid, LPCTSTR pszFileName, LPCTSTR pszHelpDir) { USES_CONVERSION; BOOL bSuccess = FALSE; CString strPathName; TCHAR *szPathName = strPathName.GetBuffer(_MAX_PATH); ::GetModuleFileName(hInstance, szPathName, _MAX_PATH); strPathName.ReleaseBuffer(); LPTYPELIB ptlib = NULL; // If a filename was specified, replace final component of path with it. if (pszFileName != NULL) { int iBackslash = strPathName.ReverseFind('\\'); if (iBackslash != -1) strPathName = strPathName.Left(iBackslash+1); strPathName += pszFileName; } if (SUCCEEDED(LoadTypeLib(T2COLE(strPathName), &ptlib))) { ASSERT_POINTER(ptlib, ITypeLib); LPTLIBATTR pAttr; GUID tlidActual = GUID_NULL; if (SUCCEEDED(ptlib->GetLibAttr(&pAttr))) { ASSERT_POINTER(pAttr, TLIBATTR); tlidActual = pAttr->guid; ptlib->ReleaseTLibAttr(pAttr); } // Check that the guid of the loaded type library matches // the tlid parameter. ASSERT(IsEqualGUID(tlid, tlidActual)); if (IsEqualGUID(tlid, tlidActual)) { // Register the type library. if (SUCCEEDED(RegisterTypeLib(ptlib, T2OLE((LPTSTR)(LPCTSTR)strPathName), T2OLE((LPTSTR)pszHelpDir)))) bSuccess = TRUE; } RELEASE(ptlib); } else { TRACE1("Warning: Could not load type library from %s\n", (LPCTSTR)strPathName); } return bSuccess; }
HRESULT FMediaPlayerVLC_Ex::AddPlaylistItem(const tchar* pFileName, IMediaOptions* pOptions) { if (!m_pPlaylist) return E_FAIL; USES_CONVERSION; long pos = 0; LPSAFEARRAY pSA = SafeArrayCreateVector(VT_VARIANT, 0, 1); if (pOptions->m_Vout == "") { //If GetWindowsVersion() == WindowsVista => "direct3d" //else "directx"; pOptions->m_Vout = "direct3d"; } FString StrVout; StrVout.Format(":vout=%s;", pOptions->m_Vout); FString Options = StrVout; m_bHasSubs = TRUE; if (pOptions->m_SubPath.GetLength() > 0) { Options.Append(";:sub-file: "); Options.Append(pOptions->m_SubPath); } Options.Append(";:sub-autodetect-file;:sub-autodetect-fuzzy:3;"); if (pOptions->rtOffset > 0) { FString StartTime; StartTime.Format(";:start-time:%d;", pOptions->rtOffset / 1000); Options.Append(StartTime); } _variant_t var(_bstr_t(T2OLE(Options))); SafeArrayPutElement(pSA, &pos, (void FAR *)&var); _variant_t v; v.parray = pSA; v.vt = VT_ARRAY; CComVariant vtName = L"LTV_Video"; BSTR bStrName = SysAllocString(T2OLE(pFileName)); long lId = 0; m_pPlaylist->get_itemCount(&lId); return m_pPlaylist->add(bStrName, vtName, v, &lId); }
HRESULT CADsSearch::GetColumn(CString &sCol, CStringList &sList ) { LPWSTR pszAttrName; ADS_SEARCH_COLUMN col; HRESULT hr; USES_CONVERSION; CString s; pszAttrName = T2OLE(sCol); hr = m_pSearch->GetColumn( m_hSearch, pszAttrName, &col ); if ( !SUCCEEDED(hr) ) { return hr; } hr = FormatColumn( &col, sList ); m_pSearch->FreeColumn( &col ); return hr; }
HBITMAP CEnBitmap::LoadImageFile(LPCTSTR szImagePath, COLORREF crBack) { int nType = GetFileType(szImagePath); //TRACE("Load(%ws)\n", szImagePath); switch (nType) { // i suspect it is more efficient to load // bmps this way since it avoids creating device contexts etc that the // IPicture methods requires. that method however is still valuable // since it handles other image types and transparency case FT_BMP: { HBITMAP bmp=(HBITMAP)::LoadImage(NULL, szImagePath, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE); BITMAP bi; ::GetObject(bmp, sizeof( BITMAP ), &bi); BYTE bpp = bi.bmBitsPixel >> 3; if(bpp==4){ BYTE* pBits = new BYTE[ bi.bmWidth * bi.bmHeight * bpp ]; int p = ::GetBitmapBits( bmp, bi.bmWidth * bi.bmHeight * bpp, pBits); for (int y=0; y<bi.bmHeight; ++y) { BYTE *pPixel= (BYTE *) pBits + bi.bmWidth * 4 * y; for (int x=0; x<bi.bmWidth ; ++x) { pPixel[0]= pPixel[0]*pPixel[3]/255; pPixel[1]= pPixel[1]*pPixel[3]/255; pPixel[2]= pPixel[2]*pPixel[3]/255; pPixel+= 4; } } ::SetBitmapBits(bmp, bi.bmWidth*bi.bmHeight*bpp, pBits); delete pBits; } return bmp; } case FT_UNKNOWN: return NULL; default: // all the rest { USES_CONVERSION; IPicture* pPicture = NULL; HBITMAP hbm = NULL; HRESULT hr = OleLoadPicturePath(T2OLE((LPTSTR)szImagePath), NULL, 0, crBack, IID_IPicture, (LPVOID *)&pPicture); if (pPicture) { hbm = ExtractBitmap(pPicture, crBack); pPicture->Release(); } return hbm; } } return NULL; // can't get here }
void CDlgIADs::OnParentPath() { HRESULT hr; UpdateData(TRUE); // Retrieve from UI USES_CONVERSION; IUnknown *pUnk; CWaitCursor wait; hr = App->ADsOpenObject( T2OLE( m_sParent ), IID_IUnknown, (void**) &pUnk ); ///////////////////////////////////// // Bring up the IADsContainer Dialog /////////////////////////////////////// if ( SUCCEEDED(hr) ) { pUnk->AddRef(); CDlgIADsContainer dlg( pUnk, this ); dlg.DoModal(); pUnk->Release(); } else { AfxMessageBox( GetErrorMessage(hr) ); } }
//////////////////////////////////////////////////////////////////////////////// // IADs::GetEx is similar to Get. The GetEx always return an array of variant // regardless if the attribute is single or multi value. // This is useful for VB/VBS environment. //////////////////////////////////////////////////////////////////////////////// void CDlgIADs::OnGetEx() { CString sAttr; CStringList sList; VARIANT var; HRESULT hr; m_cAttrList.GetLBText( m_cAttrList.GetCurSel(), sAttr ); m_cValueList.ResetContent(); USES_CONVERSION; ///////////////////////////// // GetEx the attribute //////////////////////////////// hr = m_pADs->GetEx( T2OLE(sAttr), &var); //////////////////////////////// // UI: populate the listbox //////////////////////////////// if ( SUCCEEDED(hr) ) { hr = VariantToStringList( var, sList ); if ( SUCCEEDED(hr) ) { PopulateListBoxFromStringList( m_cValueList, sList ); } VariantClear(&var); } }
// I need to make sure the file is registered with long filenames HRESULT WINAPI CXMLDOMDocument::UpdateRegistry(BOOL bRegister) { USES_CONVERSION; TCHAR file[MAX_PATH]; if (::GetModuleFileName(_Module.m_hInst, file, MAX_PATH)) { WIN32_FIND_DATA d; memset(&d,0,sizeof(WIN32_FIND_DATA)); HANDLE h = FindFirstFile(file,&d); if (h != INVALID_HANDLE_VALUE) { TCHAR *name = _tcsrchr(file,_T('\\')); TCHAR newFile[MAX_PATH] = _T(""); _tcsncpy(newFile,file,name-file); _tcscat(newFile,_T("\\")); _tcscat(newFile,d.cFileName); FindClose(h); _ATL_REGMAP_ENTRY regmap[2] = {{NULL,NULL},{NULL,NULL}}; regmap[0].szKey = OLESTR("XMLMODULE"); regmap[0].szData = T2OLE(newFile); return _Module.UpdateRegistryFromResource((UINT) IDR_XMLDOCUMENT, bRegister,regmap); } } return E_FAIL; }
HRESULT FMediaPlayerVLC_Ex::LoadMedia(const tchar* pFileName, IMediaOptions* pOptions) { USES_CONVERSION; HRESULT hr = E_FAIL; Stop(); if (!m_pVLC) return E_FAIL; m_pVLC->put_AutoPlay(VARIANT_FALSE); m_pVLC->put_AutoLoop(VARIANT_FALSE); if (m_pPlaylist) { CComVariant v; FString StrFileName; BSTR bStrName = SysAllocString(T2OLE(pFileName)); hr = m_pPlaylist->clear(); m_State = vlcLoading; hr = AddPlaylistItem(pFileName, pOptions); if (SUCCEEDED(hr)) { //m_GoToOffset = pOptions->rtOffset; m_GoToOffset = 0; pThisPlayer = this; m_wndView.SetTimer(0, 100, TimerProc); } } _DBGAlert("Media loaded: %s\n", pFileName); return hr; }
void COPCItem::getProperties(const CAtlArray<CPropertyDescription> &propsToRead, ATL::CAutoPtrArray<SPropertyValue> &propsRead){ unsigned noProperties = (DWORD)propsToRead.GetCount(); VARIANT *pValues = NULL; HRESULT *pErrors = NULL; DWORD *pPropertyIDs = new DWORD[noProperties]; for (unsigned i = 0; i < noProperties; i++){ pPropertyIDs[i] = propsToRead.GetAt(i).id; } propsRead.RemoveAll(); propsRead.SetCount(noProperties); USES_CONVERSION; HRESULT res = group.getServer().getPropertiesInterface()->GetItemProperties(T2OLE(name), noProperties, pPropertyIDs, &pValues, &pErrors); delete []pPropertyIDs; if (FAILED(res)){ throw OPCException("Failed to restrieve property values", res); } for (unsigned i = 0; i < noProperties; i++){ CAutoPtr<SPropertyValue> v; if (!FAILED(pErrors[i])){ v.Attach(new SPropertyValue(propsToRead[i], pValues[i])); } propsRead[i]=v; } COPCClient::comFree(pErrors); COPCClient::comFreeVariant(pValues, noProperties); }
// // IDirectoryObject::DeleteDSObject(); // // void CDlgIDirectoryObject::OnDelete() { CDeleteObjectDlg dlg; CString s, sMsg; HRESULT hr; if ( dlg.DoModal() == IDOK ) { USES_CONVERSION; // Example: CN=jsmith s = dlg.GetObjectName(); hr = m_pDirObject->DeleteDSObject( T2OLE(s) ); } if ( SUCCEEDED(hr) ) { sMsg.Format(_T("Object '%s' was sucessfully deleted"), s); AfxMessageBox( sMsg ); } else { AfxMessageBox(GetErrorMessage(hr)); return; } }
//************************************************************************** void AddItemDlg::OnSelchangeFlat() { USES_CONVERSION; if( !browse.IsOk() ) return; CWaitCursor wait; m_itemID.Empty(); GetDlgItem(ID_OPC_ITEMPARAMETERS)->EnableWindow(FALSE); int nSel = m_flat.GetCurSel(); if ( nSel != LB_ERR ) { m_flat.GetText(nSel,m_itemID); } else return; // Ask the server for the itemID LPWSTR pName = NULL; HRESULT hr = browse.GetItemID( T2OLE(m_itemID.GetBuffer(0)), &pName ); if( SUCCEEDED(hr) ) { m_itemID = pName; CoTaskMemFree( pName ); GetDlgItem(ID_OPC_ITEMPARAMETERS)->EnableWindow(TRUE); } UpdateData( FALSE ); }
HRESULT CComUDPListener::InvokeOnDatagramReceived(const tstring& addr, const unsigned int port) { try { USES_CONVERSION; // Prepare array of params in reverse order const int count = 2; VARIANT rgvars[2]; for(int i = 0; i < count; ++i) ::VariantInit(&rgvars[i]); BSTR bstrAddr = ::SysAllocString(T2OLE(addr.c_str())); rgvars[1].vt = VT_BSTR; V_BSTR(&rgvars[1]) = bstrAddr; rgvars[0].vt = VT_I4; V_I4(&rgvars[0]) = port; // Invoke event HRESULT hResult = SafeInvokeEvent(1, rgvars, count); // Free array of params for(int i = 0; i < count; ++i) ::VariantClear(&rgvars[i]); return hResult; } catch(...) { return E_FAIL; } }
void CDlgIDirectorySearch::OnDblClickListView(NMHDR* pNMHDR, LRESULT* pResult) { int idx; *pResult = 0; idx = m_cListView.GetNextItem(-1, LVNI_SELECTED); if ( idx == -1 ) { return; } CHeaderCtrl *pHeader; int nCount; pHeader = m_cListView.GetHeaderCtrl(); if ( !pHeader ) { return; } nCount = pHeader->GetItemCount(); // Get the text CString s; s = m_cListView.GetItemText( idx, nCount-1 ); if ( !s.GetLength() ) { return; } USES_CONVERSION; HRESULT hr; IUnknown *pUnk=NULL; CString sUserName; hr = App->ADsOpenObject( T2OLE( s ), IID_IUnknown, (void**) &pUnk ); ///////////////////////////////////// // Bring up the IADs Dialog /////////////////////////////////////// if ( SUCCEEDED(hr) ) { pUnk->AddRef(); CDlgIADs dlg( pUnk ); dlg.DoModal(); pUnk->Release(); } else { AfxMessageBox(GetErrorMessage(hr)); } }
HRESULT LoadTypeLib(HINSTANCE hInstTypeLib, LPCOLESTR lpszIndex, BSTR* pbstrPath, ITypeLib** ppTypeLib) { ATLASSERT(pbstrPath != NULL && ppTypeLib != NULL); if (pbstrPath == NULL || ppTypeLib == NULL) return E_POINTER; *pbstrPath = NULL; *ppTypeLib = NULL; USES_CONVERSION; ATLASSERT(hInstTypeLib != NULL); TCHAR szModule[MAX_PATH+10]; DWORD dwFLen = ::GetModuleFileName(hInstTypeLib, szModule, MAX_PATH); if( dwFLen == 0 ) return HRESULT_FROM_WIN32(::GetLastError()); else if( dwFLen == MAX_PATH ) return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER); // get the extension pointer in case of fail LPTSTR lpszExt = NULL; lpszExt = ::PathFindExtension(szModule); if (lpszIndex != NULL) lstrcat(szModule, OLE2CT(lpszIndex)); LPOLESTR lpszModule = T2OLE(szModule); HRESULT hr = ::LoadTypeLib(lpszModule, ppTypeLib); if (!SUCCEEDED(hr)) { // typelib not in module, try <module>.tlb instead lstrcpy(lpszExt, _T(".tlb")); lpszModule = T2OLE(szModule); hr = ::LoadTypeLib(lpszModule, ppTypeLib); } if (SUCCEEDED(hr)) { *pbstrPath = ::SysAllocString(lpszModule); if (*pbstrPath == NULL) hr = E_OUTOFMEMORY; } return hr; }
// Set state and name in the group void GroupParamsDlg::OnApply() { USES_CONVERSION; UpdateData( TRUE ); HRESULT hr = opcGroup.SetState( &m_rate, &m_rate, &m_active, &m_timebias, &m_deadband, &m_LCID, &client ); hr = opcGroup.SetName( T2OLE(m_name.GetBuffer(0)) ); UpdateData( FALSE ); }
HRESULT CADsSearch::GetColumn( LPCTSTR pszCol, PADS_SEARCH_COLUMN pCol ) { LPWSTR pszAttrName; USES_CONVERSION; pszAttrName = T2OLE(pszCol); return m_pSearch->GetColumn( m_hSearch, pszAttrName, pCol ); }
void CWebWindow::OnCmdSetVariable(LPCTSTR bstrVarName, LPCTSTR bstrVarValue) { USES_CONVERSION; if(CString("Invoke_StartAutoUpdate").CompareNoCase(bstrVarName)==0) { _bstr_t VarValue = bstrVarValue; //((CMainDlg*)GetMessageParent())->Invoke_StartAutoUpdate(bstrVarValue); GetMessageParent()->PostMessage(WM_INVOKE_STARTAUTO_UPDATE,(WPARAM)VarValue.copy()); PostMessage(WM_CLOSE); } else if(CString("LoadXML").CompareNoCase(bstrVarName)==0) { m_bQueryAttachXML =TRUE; LoadXML(bstrVarValue); } else if(CString(_T("_LoadDropFiles")).CompareNoCase(bstrVarName)==0) { // Load Script Function bstrVarValue, and SendFiles Array [4/22/2002] CComPtr<IHTMLDocument> pDoc; pDoc.Attach((IHTMLDocument*)m_browser.GetDocument()); if(pDoc!=NULL) { CComPtr<IDispatch> spDispScript = NULL; HRESULT hr = pDoc->get_Script(&spDispScript); if(spDispScript) { DISPID dispid = -1; OLECHAR FAR* szMember = T2OLE(const_cast<LPTSTR>(bstrVarValue)); hr = spDispScript->GetIDsOfNames(IID_NULL, &szMember, 1, LOCALE_SYSTEM_DEFAULT, &dispid); if(SUCCEEDED(hr)) { CComVariant varResult; DISPPARAMS params = { &varFilesData, NULL, 1, 0 }; hr = spDispScript->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, ¶ms, &varResult, NULL, NULL); } } } } else if(CString("Invoke_CreateChat").CompareNoCase(bstrVarName)==0) { // <строка вида> = "Name#Description#Message#UserId,UserId,UserId" [11/5/2002] _bstr_t VarValue = bstrVarValue; GetMessageParent()->PostMessage(WM_INVOKE_CREATECHAT,(WPARAM)VarValue.copy()); } else if(CString("Invoke_SendMessage").CompareNoCase(bstrVarName)==0) { // <строка вида> = "Message#UserId,UserId,UserId" [11/5/2002] _bstr_t VarValue = bstrVarValue; GetMessageParent()->PostMessage(WM_INVOKE_SENDMESSAGE,(WPARAM)VarValue.copy()); } else g_ViewVariablesList.SetVariable(bstrVarName,bstrVarValue); }
//------------------------------------------------------------------* HRESULT CFCMessageSessionThread::ConnectToOnlineServer(IMessages **ppMessages) { MULTI_QI queue[1]; COSERVERINFO serverInfo; DWORD clsctx; CComPtr<ICustomConnect> pConn; CComPtr<IUnknown>pUnk; CComBSTR sInit; HRESULT hr = S_OK; FC_PCHECK_HR(ppMessages,E_POINTER); *ppMessages = NULL; queue[0].pItf = NULL; queue[0].hr = 0; // set up server node info: serverInfo.dwReserved1 = 0; serverInfo.dwReserved2 = 0; USES_CONVERSION; serverInfo.pwszName = T2OLE(m_pRawMsgSession->m_strMachineName); serverInfo.pAuthInfo = 0; clsctx = CLSCTX_REMOTE_SERVER | CLSCTX_LOCAL_SERVER; if(m_pRawMsgSession->m_clsidConn.IsEmpty()) { queue[0].pIID = &IID_IMessages; hr = ::CoCreateInstanceEx(m_pRawMsgSession->m_clsidCtrl, NULL, clsctx, &serverInfo,FC_ARRAY_LEN(queue),queue); if(SUCCEEDED(hr)) { *ppMessages = (IMessages *)queue[0].pItf; } return hr; } //custom connect case queue[0].pIID = &IID_ICustomConnect; hr = ::CoCreateInstanceEx(m_pRawMsgSession->m_clsidConn, NULL, clsctx, &serverInfo, FC_ARRAY_LEN(queue), queue); if(FAILED(hr)) { return hr; } pConn.Attach((ICustomConnect*)queue[0].pItf); sInit = m_pRawMsgSession->m_strInit; hr = pConn->CreateControlManagement(sInit,&pUnk); if(FAILED(hr)) { return hr; } return pUnk->QueryInterface(IID_IMessages,(void**)ppMessages); }
//------------------------------------------------------------------* HRESULT COPCConnection::DoConnect() { USES_CONVERSION; HRESULT hr; _ASSERTE(!m_bConnected); MULTI_QI queue[1]; queue[0].pIID = &IID_IOPCServer; queue[0].pItf = NULL; queue[0].hr = 0; // set up server node info: COSERVERINFO serverInfo; serverInfo.dwReserved1 = 0; serverInfo.dwReserved2 = 0; serverInfo.pwszName = T2OLE(m_sMachineName); serverInfo.pAuthInfo = NULL; //HACK hardcode from C:\4c2\COM\softing\fc\AddOns\Softing\4CPCTarget\inc\CSC_OnlSrv.idl //CLSID_OPCServer 379165A5-C2BF-47a8-8F60-73EDE1FD6001 CLSID CLSIDOPCServer; //HACK CLSIDFromString(L"{5425B8A4-754D-496a-AF31-7D78A530E58D}", &CLSIDOPCServer);//HACK hr = CoCreateInstanceEx(CLSIDOPCServer, NULL, CLSCTX_REMOTE_SERVER | CLSCTX_LOCAL_SERVER, &serverInfo, 1, queue); if (FAILED(hr)) { return hr; } m_pOPCServer = (IOPCServer*) queue[0].pItf; DWORD dummy; hr = m_pOPCServer->AddGroup(L"AsyncOPC", TRUE, 1000, 0, NULL, NULL, LOCALE_NEUTRAL, &m_hGroup1, &dummy, IID_IOPCItemMgt, (IUnknown**)&m_pItemMgt); if (FAILED(hr)) { m_pOPCServer->Release(); m_pOPCServer=NULL; return hr; } hr = m_pItemMgt->QueryInterface(IID_IOPCSyncIO, (void **)&m_pSyncIO); if (FAILED(hr)) { m_pItemMgt->Release(); m_pItemMgt=NULL; m_pOPCServer->RemoveGroup(m_hGroup1, TRUE); m_pOPCServer->Release(); m_pOPCServer=NULL; return hr; } TRACE(_T("COPCConnection::DoConnect to %s\n"), (LPCTSTR)m_sMachineName); m_bConnected = true; return S_OK; }
BOOL CCsvRecordset::GetField(short iIndex, SYSTEMTIME& Data) { _ASSERTE(IsOpen()); _ASSERTE(iIndex>=0 && iIndex<m_pDb->m_nCols); if( iIndex < 0 || iIndex >= m_pDb->m_nCols ) return FALSE; TCHAR szValue[100] = { 0 }; if( !GetField(iIndex, szValue, 99) ) return FALSE; // Use the slow, but neat VARIANT functions to convert to a date/time USES_CONVERSION; DATE d = { 0 }; ::VarDateFromStr(T2OLE(szValue), 1033, LOCALE_NOUSEROVERRIDE, &d); // 1033 = US/UK locale return SUCCEEDED( ::VariantTimeToSystemTime(d, &Data) ); }
void registerAppInfo(HINSTANCE hInstance) { HINSTANCE hPrevInst = AfxGetResourceHandle(); AfxSetResourceHandle(hInstance); USES_CONVERSION; HRESULT hRes = S_OK; CComPtr<IRegistrar> p; hRes = CoCreateInstance(CLSID_Registrar, NULL, CLSCTX_INPROC_SERVER, IID_IRegistrar, (void**)&p); if (SUCCEEDED (hRes)) { TCHAR szRegKey [MAX_PATH]; CString strAutoCADRegistryPath = acrxProductKey (); _tcscpy (szRegKey, strAutoCADRegistryPath); const TCHAR *pszDelimiter = "\\"; TCHAR *pszToken = _tcstok (szRegKey, pszDelimiter); const TCHAR *pszIds[] = { "SOFTWARE", "AUTODESK", "AUTOCAD", "RELEASE", "AUTH" }; int nCount = 0; while (NULL != pszToken) { p->AddReplacement (T2OLE(pszIds[nCount]), T2OLE(pszToken)); pszToken = _tcstok (NULL, pszDelimiter); if (NULL == pszToken) break; nCount++; } TCHAR szModule [_MAX_PATH]; GetModuleFileName (hInstance, szModule, MAX_PATH); LPOLESTR pszModule = T2OLE (szModule); p->AddReplacement (T2OLE("MODULE"), pszModule); LPCOLESTR szType = OLESTR ("REGISTRY"); p->ResourceRegister (pszModule, IDR_REGISTRY_APP, szType); } AfxSetResourceHandle(hPrevInst); }
void CDlgIADs::OnGet() { CString sAttr; CStringList sList; VARIANT var; HRESULT hr; m_cAttrList.GetLBText( m_cAttrList.GetCurSel(), sAttr ); if ( sAttr == STRING_SEPARATOR ) { MessageBeep(0); return; } m_cValueList.ResetContent(); USES_CONVERSION; ///////////////////////////// // Get the attribute //////////////////////////////// hr = m_pADs->Get( T2OLE(sAttr), &var); //////////////////////////////// // UI: populate the listbox //////////////////////////////// if ( SUCCEEDED(hr) ) { hr = VariantToStringList( var, sList ); if ( SUCCEEDED(hr) ) { PopulateListBoxFromStringList( m_cValueList, sList ); } VariantClear(&var); } else { CString s; s = GetErrorMessage( hr ); m_cValueList.AddString( s ); } }
SCODE _AfxParseDisplayName(LPMONIKER lpmk, LPBC lpbc, LPTSTR lpszRemainder, ULONG* cchEaten, LPMONIKER* plpmkOut) { USES_CONVERSION; ASSERT(lpmk != NULL); ASSERT(AfxIsValidString(lpszRemainder)); ASSERT(cchEaten != NULL); ASSERT(plpmkOut != NULL); SCODE sc; if (lpbc != NULL) { // ask moniker to parse the display name itself sc = lpmk->ParseDisplayName(lpbc, NULL, T2OLE(lpszRemainder), cchEaten, plpmkOut); } else { // skip leading delimiters int cEaten = 0; LPTSTR lpszSrc = lpszRemainder; while (*lpszSrc != '\0' && (*lpszSrc == '\\' || *lpszSrc == '/' || *lpszSrc == ':' || *lpszSrc == '!' || *lpszSrc == '[')) { if (_istlead(*lpszSrc)) ++lpszSrc, ++cEaten; ++lpszSrc; ++cEaten; } // parse next token in lpszRemainder TCHAR szItemName[_MAX_PATH]; LPTSTR lpszDest = szItemName; while (*lpszSrc != '\0' && *lpszSrc != '\\' && *lpszSrc != '/' && *lpszSrc != ':' && *lpszSrc != '!' && *lpszSrc != '[' && cEaten < _MAX_PATH-1) { if (_istlead(*lpszSrc)) *lpszDest++ = *lpszSrc++, ++cEaten; *lpszDest++ = *lpszSrc++; ++cEaten; } *cchEaten = cEaten; sc = CreateItemMoniker(OLESTDDELIMOLE, T2COLE(szItemName), plpmkOut); } return sc; }
STDMETHODIMP CHelloWorld::SayHello() { USES_CONVERSION; // Get the network name of this computer TCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1]; DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1; if (!GetComputerName(szComputerName, &dwSize)) return E_FAIL; // failed to get the name of this computer // Say Hello to the client Fire_OnSayHello(T2OLE(szComputerName)); // TODO: Add more code here return S_OK; }
//************************************************************************** // When the user selects a branch, fill the list of tags void AddItemDlg::OnSelchangedTree(NMHDR* pNMHDR, LRESULT* pResult) { USES_CONVERSION; if( !browse.IsOk() ) return; CWaitCursor wait; HTREEITEM item = m_tree.GetSelectedItem( ); HRESULT hr = BrowseHere( item ); // move browse position here if( SUCCEEDED(hr) ) { // get the tags m_tags.ResetContent(); IEnumString* pEnumString = NULL; hr = browse.BrowseOPCItemIDs(OPC_LEAF, T2OLE(m_filter.GetBuffer(0)), m_vt, 0, // no filtering (or OPC_READABLE|OPC_WRITEABLE) &pEnumString); if( hr == S_OK ) { LPWSTR pName[NEXT_COUNT]; ULONG count = 0; do { hr = pEnumString->Next(NEXT_COUNT, &pName[0], &count); // CString does translation from UNICODE to native type // (depends on the way the application is built) for( ULONG index=0; index<count; index++ ) { CString name( pName[index] ); m_tags.AddString( name ); CoTaskMemFree( pName[index] ); } } while( hr == S_OK ); pEnumString->Release(); } } hr = S_OK; for( int i=0; i<10 && SUCCEEDED(hr); i++ ) hr = browse.ChangeBrowsePosition( OPC_BROWSE_UP, empty ); if( pResult ) *pResult = 0; }