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;
}
