STDMETHODIMP CBDictionary::get_Keys(VARIANT *pKeysArray)
{
CComSafeArray<VARIANT> bstrArray;
VARIANT* pVar;
HRESULT hr;
m_cs.Enter();
hr = bstrArray.Create((ULONG)m_posArray.GetCount());
if(FAILED(hr))
{
m_cs.Leave();
return hr;
}
pVar = (VARIANT*)bstrArray.m_psa->pvData;
for(int i = 0; i < (int)m_posArray.GetCount(); i ++)
{
hr = VariantCopy(&pVar[i], (VARIANT*)&m_posArray[i]->m_key);
if(FAILED(hr))
{
m_cs.Leave();
bstrArray.Destroy();
return hr;
}
}
m_cs.Leave();
pKeysArray->vt = VT_ARRAY | VT_VARIANT;
pKeysArray->parray = bstrArray.Detach();
return S_OK;
}
STDMETHODIMP CDlrComServer::GetIntArray(SAFEARRAY **ppsaRetVal)
{
CComSafeArray<INT> csaData;
void HUGEP *pvData = NULL;
HRESULT hr = S_OK;
int rgData [] = { 1, 2, 3, 4, 5 };
hr = csaData.Create(5, 0);
if (FAILED(hr))
goto Error;
hr = SafeArrayAccessData((LPSAFEARRAY)csaData, (void HUGEP **)&pvData);
if (FAILED(hr))
goto Error;
memcpy((void*)pvData, rgData, sizeof(rgData));
hr = SafeArrayUnaccessData((LPSAFEARRAY)csaData);
if (FAILED(hr))
goto Error;
*ppsaRetVal = csaData.Detach();
Error:
return hr;
}
STDMETHODIMP CXRecords::GetRows(VARIANT key, VARIANT* pVal)
{
if(!m_pFields)return SetErrorInfo(s_errInit);
CComSafeArray<VARIANT> bstrArray;
VARIANT* pVar;
HRESULT hr;
int i = 0;
int pos;
int count = m_listRecords->GetCount();
pos = m_pFields->FindField(key);
if(pos < 0 || pos >= (int)m_pFields->GetCount())
return DISP_E_BADINDEX;
hr = bstrArray.Create(count);
if(FAILED(hr))return hr;
pVar = (VARIANT*)bstrArray.m_psa->pvData;
for(i = 0; i < count; i ++)
{
hr = VariantCopy(&pVar[i], (VARIANT*)&m_listRecords->GetValue(i)->m_arrayVariant[pos]);
if(FAILED(hr))
{
bstrArray.Destroy();
return hr;
}
}
pVal->vt = VT_ARRAY | VT_VARIANT;
pVal->parray = bstrArray.Detach();
return S_OK;
}
STDMETHODIMP CDlrComServer::GetByteArray(SAFEARRAY **ppsaRetVal)
{
CComBSTR cbstrTestData(L"GetByteArrayTestData");
CComSafeArray<BYTE> csaData;
void HUGEP *pvData = NULL;
DWORD cbData;
HRESULT hr = S_OK;
// create a stream of bytes encoded as UNICODE text
cbData = SysStringByteLen(cbstrTestData.m_str);
hr = csaData.Create(cbData, 0);
if (FAILED(hr))
goto Error;
hr = SafeArrayAccessData((LPSAFEARRAY)csaData, (void HUGEP **)&pvData);
if (FAILED(hr))
goto Error;
memcpy((void*)pvData, cbstrTestData.m_str, cbData);
hr = SafeArrayUnaccessData((LPSAFEARRAY)csaData);
if (FAILED(hr))
goto Error;
if (FAILED(hr))
goto Error;
*ppsaRetVal = csaData.Detach();
Error:
return hr;
}
HRESULT GetAssemblyFromAppDomain(_AppDomain* appDomain, const wchar_t* assemblyName, _Assembly **assembly)
{
SAFEARRAY* safearray;
CComSafeArray<IUnknown*> assemblies;
CHECKCOM(appDomain->GetAssemblies(&safearray));
assemblies.Attach(safearray);
for (int i = 0, n = assemblies.GetCount(); i < n; i++)
{
CComPtr<_Assembly> a;
a = assemblies[i];
if (a == nullptr)
continue;
CComBSTR assemblyFullName;
CHECKCOM(a->get_FullName(&assemblyFullName));
if (assemblyFullName != nullptr && _wcsnicmp(assemblyFullName, assemblyName, wcslen(assemblyName)) == 0)
{
*assembly = a.Detach();
return S_OK;
}
}
return E_FAIL;
}
ITunesEventInterface::ITunesIdSet
ITunesComEventSink::getIdsFromSafeArray( long index,
CComSafeArray<VARIANT>& array )
{
VARIANT elem;
LONG idx2d[2];
idx2d[0] = index;
idx2d[1] = 0;
array.MultiDimGetAt( idx2d, elem );
long sourceId = elem.lVal;
idx2d[1] = 1;
array.MultiDimGetAt( idx2d, elem );
long playlistId = elem.lVal;
idx2d[1] = 2;
array.MultiDimGetAt( idx2d, elem );
long trackId = elem.lVal;
idx2d[1] = 3;
array.MultiDimGetAt( idx2d, elem );
long dbId = elem.lVal;
ITunesEventInterface::ITunesIdSet ids = { sourceId, playlistId, trackId, dbId };
return ids;
}
void CRegionDlg::OnBnClickedSelect()
{
UpdateData();
ShowWindow(SW_HIDE);
CRect rcCapture;
CComPtr<ITSelectionInfo> pSelInfo;
CComSafeArray<VARIANT, VT_VARIANT> arSafePoints;
int nCount = 0;
LONG hWnd = NULL;
VARIANT points;
if (!theApp.Select(tsSelectionRectangle, pSelInfo))
{
goto Exit;
}
// Capture region
hWnd = pSelInfo->WindowHandle;
pSelInfo->get_Points(&points);
// Ttransform safe arry points
arSafePoints.CopyFrom(points.parray);
nCount = (int)arSafePoints.GetCount();
ATLASSERT(2 == nCount);
if (2 != nCount)
{
goto Exit;
}
rcCapture.SetRect(GET_X_LPARAM(arSafePoints[0].lVal), GET_Y_LPARAM(arSafePoints[0].lVal),
GET_X_LPARAM(arSafePoints[1].lVal), GET_Y_LPARAM(arSafePoints[1].lVal));
// Fill the values
m_strWindowName = theApp.GetWindowText((HWND)(LONG_PTR)hWnd);
m_strWindowHandle.Format(_T("%X"), hWnd);
m_nX = rcCapture.left;
m_nY = rcCapture.top;
m_nWidth = rcCapture.Width();
m_nHeight = rcCapture.Height();
// Capture
DoCapture(hWnd, rcCapture);
UpdateData(FALSE);
Exit:
if (m_nFullHeight > 0)
{
//restore the window
theApp.RestoreWindow(this, m_nFullHeight);
m_nFullHeight = 0;
}
ShowWindow(SW_SHOW);
}
HRESULT RegisterWithGDEventFramework() {
CComPtr<IGoogleDesktopRegistrar> registrar;
HRESULT hr = registrar.CoCreateInstance(L"GoogleDesktop.Registrar");
if (SUCCEEDED(hr)) {
CComBSTR our_guid(CONSOLE_PLUGIN_GUID);
WCHAR icon_path[_MAX_PATH + 1] = {0};
ATLVERIFY(::GetModuleFileNameW(NULL, icon_path, _MAX_PATH - 2) != 0);
SafeStrCat(icon_path, L"@0", _MAX_PATH+1);
CComSafeArray<VARIANT> description;
ATLVERIFY(SUCCEEDED(description.Create(8)));
VARIANT* props = reinterpret_cast<VARIANT*>(description.m_psa->pvData);
for (DWORD i = 0; i < description.GetCount(); ++i) {
props[i].vt = VT_BSTR;
}
props[0].bstrVal = ::SysAllocString(L"Title");
props[1].bstrVal = ::SysAllocString(L"Console Events");
props[2].bstrVal = ::SysAllocString(L"Description");
props[3].bstrVal = ::SysAllocString(L"Outputs events from Google Desktop to the console");
props[4].bstrVal = ::SysAllocString(L"Icon");
props[5].bstrVal = ::SysAllocString(icon_path);
props[6].bstrVal = ::SysAllocString(L"Homepage");
props[7].bstrVal = ::SysAllocString(L"http://desktop.google.com");
VARIANT desc;
desc.vt = VT_ARRAY | VT_VARIANT;
desc.parray = description;
hr = registrar->StartComponentRegistration(our_guid, desc);
if (SUCCEEDED(hr)) {
CComPtr<IUnknown> unknown;
hr = registrar->GetRegistrationInterface(CComBSTR(L"GoogleDesktop.EventRegistration"),
&unknown);
ATLASSERT(SUCCEEDED(hr));
CComQIPtr<IGoogleDesktopRegisterEventPlugin> event_registration(unknown);
if (event_registration != NULL) {
long cookie = 0;
hr = event_registration->RegisterPlugin(our_guid, &cookie);
if (SUCCEEDED(hr)) {
hr = registrar->FinishComponentRegistration();
if (SUCCEEDED(hr)) {
hr = StoreRegistrationCookie(cookie);
}
}
}
}
}
return hr;
}
void displayCCOMBSTRFiles(CComSafeArray<BSTR> fileSet)
{
std::wcout << "Displaying Files Generated from the C++ Interface from COM OBJECT" << std::endl;
for (ULONG i = 0; i < fileSet.GetCount(); i++)
{
std::cout << "Qualified File # " <<i<<" : "<< convertBSTR2stdSTR(fileSet.GetAt(i)) << "\n";
}
}
CComSafeArray<BSTR> convertVector2CCOMSafeArray(Result x)
{
\
CComSafeArray<BSTR> result;
for (std::string inst : x)
{
result.Add(convertstdSTR2BSTR(inst));
}
return result;
}
// This is an example of an exported function.
NATIVELIBRARYCONSUMER_API int STDAPICALLTYPE fnNativeLibraryConsumer(SAFEARRAY** retval)
{
//sample of returning array from C++
CComSafeArray<VARIANT>* arr = new CComSafeArray<VARIANT>(2);
VARIANT var;
var.vt= VT_INT;
var.intVal = 123;
arr->SetAt(0,var);
arr->SetAt(1,var);
*retval = *(arr->GetSafeArrayPtr());
uses = new CNativeLibrary();
return 42;
}
STDMETHODIMP CDlrComServer::GetObjArray(SAFEARRAY **ppsaRetVal)
{
CComSafeArray<LPUNKNOWN> csaData;
void HUGEP *pvData = NULL;
IUnknown* punkThis = NULL;
IUnknown* punkOther = NULL;
void* rgData[] = { 0, 0 };
HRESULT hr = S_OK;
hr = csaData.Create(2, 0);
if (FAILED(hr))
goto Error;
hr = SafeArrayAccessData((LPSAFEARRAY)csaData, (void HUGEP **)&pvData);
if (FAILED(hr))
goto Error;
hr = this->QueryInterface(IID_IUnknown, (void**)&punkThis);
if (FAILED(hr))
goto Error;
hr = CoCreateInstance(CLSID_DlrComServer, NULL, CLSCTX_INPROC_SERVER, IID_IUnknown, (void**)&punkOther);
if (FAILED(hr))
goto Error;
rgData[0] = punkThis;
rgData[1] = punkOther;
memcpy((void*)pvData, rgData, sizeof(rgData));
hr = SafeArrayUnaccessData((LPSAFEARRAY)csaData);
if (FAILED(hr))
goto Error;
punkThis = 0;
punkOther = 0;
*ppsaRetVal = csaData.Detach();
Error:
if (punkThis)
punkThis->Release();
if (punkOther)
punkOther->Release();
return hr;
}
/**
* Output = Map of topic id and field data - Map to be deleted by caller
*/
std::map<long,CComVariant>* RTDClient::readNewData(){
SAFEARRAY *data_sa;
long topic_count = 0;
HRESULT hr = comObjectScripRTD->RefreshData( &topic_count, &data_sa );
// Pass Address of SAFEARRAY pointer so that we get pointer to 2D safearray
if( FAILED(hr) ){ // Output Data has to be deleted by client
std::cout << "RefreshData COM failure." << " - hr - " << hr << std::endl;
return 0;
}
CComSafeArray<VARIANT> data; // Passing data_sa as Constructor input will copy it, but we need to destroy it after use
data.Attach( data_sa ); // So attach instead and let CComSafeArray handle it
ULONG row_count = data.GetCount(1); // No of Rows = 2nd Dimension Count
if( row_count == 0) return 0 ;
std::map<long,CComVariant> *output = new std::map<long,CComVariant>; // Map: Topicid, Field Data
long index[2];
for( ULONG i=0 ; i<row_count; i++ ){
index[0] = 0; // 0,x - Topic ids. 1,x - Data
index[1] = i;
CComVariant topic_id_var;
data.MultiDimGetAt( index, topic_id_var);
long topic_id = (long)MiscUtil::getLong( topic_id_var );
index[0] = 1;
index[1] = i;
CComVariant topic_data_var;
data.MultiDimGetAt( index, topic_data_var);
if( output->count(topic_id) != 0 && (*output)[topic_id] != topic_data_var ){
std::cout << "Duplicate:"; MiscUtil::printVariant((*output)[topic_id]); std::cout << "-"; MiscUtil::printVariant(topic_data_var);
std::cout << std::endl;
//abort(); // If exists - we can have multiple topic values in same call => use vector
}
(*output)[topic_id] = topic_data_var;
}
return output;
}
void printHistory(CComVariant history) {
if (history.vt == (VT_ARRAY | VT_I2)) {
printf("Ping code history for server: ");
CComSafeArray<SHORT> codes = history.parray;
int codeCount = codes.GetCount();
for (int i = 0; i < codeCount; i++) {
printf("%hd ", codes[i]);
}
printf("\n");
codes.Destroy();
}
else {
printf("Incorrect variant type\n");
}
}
STDMETHODIMP CotProjTransform::Transform(LONG count, SAFEARRAY** inX, SAFEARRAY** inY, SAFEARRAY** outX, SAFEARRAY** outY)
{
if(!CheckPointer())
{
return E_FAIL;
}
double *dxs =new double[count];
double *dys =new double[count];
CComSafeArray<double> safeInx;
CComSafeArray<double> safeIny;
safeInx.Attach(*inX);
safeIny.Attach(*inY);
for(long i=0;i<count;i++)
{
dxs[i] =safeInx[i];
dys[i] =safeIny[i];
}
safeInx.Detach();
safeIny.Detach();
//转换
(*m_ppTrans)->Transform(count,dxs,dys);
//将转换结果放到输出数组中
safeInx.Attach(*outX);
safeIny.Attach(*outY);
for(long i=0;i<count;i++)
{
safeInx[i] = dxs[i] ;
safeIny[i] = dys[i] ;
}
safeInx.Detach();
safeIny.Detach();
return S_OK;
}
LRESULT IGToolCutterSquare::OnMouseUp (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
CComSafeArray <int> spSafeArrayPts;
spSafeArrayPts.Add (m_xPos1);
spSafeArrayPts.Add (m_yPos1);
m_xPos1 = GET_X_LPARAM(lParam);
m_yPos1 = GET_Y_LPARAM(lParam);
m_pFrame->ConvertCoordFrameToPixel ((LONG*)&m_xPos1, (LONG*)&m_yPos1);
spSafeArrayPts.Add (m_xPos1);
spSafeArrayPts.Add (m_yPos1);
CComVariant spVarArray (spSafeArrayPts);
int nTypeSelection = IGSELECTION_REPLACE;
if (::GetKeyState (VK_SHIFT) < 0)
nTypeSelection = IGSELECTION_ADD;
else if (::GetKeyState (VK_CONTROL) < 0)
nTypeSelection = IGSELECTION_REMOVE;
m_pFrame->ManageSelection (IGSELECTION_SQUARE | nTypeSelection, &spVarArray);
return 0L;
}
STDMETHODIMP CLDAPQuery::explodeDn(
/* [in] */ BSTR str,
/* [in] */ ULONG notypes,
/* [retval][out] */ SAFEARRAY **result)
{
PTCHAR *vals = ldap_explode_dn(CComBSTR(str), notypes);
m_errorCode = LdapGetLastError();
if(vals)
{
CComSafeArray<VARIANT> dnValues;
for(LONG i = 0L; vals[i]!=NULL; i++)
{
dnValues.Add(CComVariant(vals[i]));
}
ldap_value_free(vals);
*result = dnValues.Detach();
}
return S_OK;
}
STDMETHODIMP CTextSearch::GetResults(SAFEARRAY ** files)
{
// TODO: Add your implementation code here
Search searchService;
std::string path = searchService.ConvertBSTRToMBS(_searchPath);
//std::string keyword = searchService.ConvertBSTRToMBS(_searchKeyword);
std::vector<std::string> keywords;
for (int i = 0; i < (int)_searchKeywords.GetCount(); ++i)
keywords.push_back(searchService.ConvertBSTRToMBS(_searchKeywords[i].Copy()));
std::vector<std::string> results = searchService.StartTextSearch(keywords, path, _searchAll);
CComSafeArray<BSTR> temp;
for (auto result : results)
temp.Add(CComBSTR(result.c_str()));
*files = temp.Detach();
return S_OK;
}
void lvDCOMInterface::getLabviewValue(const char* param, T* value, size_t nElements, size_t& nIn)
{
if (value == NULL)
{
throw std::runtime_error("getLabviewValue failed (NULL)");
}
if (param == NULL || *param == '\0')
{
throw std::runtime_error("getLabviewValue: param is NULL");
}
CComVariant v;
char vi_name_xpath[MAX_PATH_LEN], control_name_xpath[MAX_PATH_LEN];
_snprintf(vi_name_xpath, sizeof(vi_name_xpath), "/lvinput/section[@name='%s']/vi/@path", m_configSection.c_str());
_snprintf(control_name_xpath, sizeof(control_name_xpath), "/lvinput/section[@name='%s']/vi/param[@name='%s']/read/@target", m_configSection.c_str(), param);
CComBSTR vi_name(doPath(vi_name_xpath).c_str());
CComBSTR control_name(doXPATH(control_name_xpath).c_str());
if (vi_name.Length() == 0 || control_name.Length() == 0)
{
throw std::runtime_error("getLabviewValue: vi or control is NULL");
}
getLabviewValue(vi_name, control_name, &v);
if ( v.vt != (VT_ARRAY | CVarTypeInfo<T>::VT) )
{
throw std::runtime_error("getLabviewValue failed (type mismatch)");
}
CComSafeArray<T> sa;
sa.Attach(v.parray);
nIn = ( sa.GetCount() > nElements ? nElements : sa.GetCount() );
for(LONG i=0; i<nIn; ++i)
{
value[i] = sa.GetAt(i);
}
sa.Detach();
}
STDMETHODIMP CBQueue::get_Items(VARIANT *pItemsArray)
{
CComSafeArray<VARIANT> bstrArray;
VARIANT* pVar;
HRESULT hr;
POSITION pos;
int i;
m_cs.Enter();
hr = bstrArray.Create((ULONG)m_listItems.GetCount());
if(FAILED(hr))
{
m_cs.Leave();
return hr;
}
pVar = (VARIANT*)bstrArray.m_psa->pvData;
pos = m_listItems.GetHeadPosition();
i = 0;
while(pos)
{
hr = VariantCopy(&pVar[i ++], &m_listItems.GetNext(pos));
if(FAILED(hr))
{
m_cs.Leave();
return hr;
}
}
m_cs.Leave();
pItemsArray->vt = VT_ARRAY | VT_VARIANT;
pItemsArray->parray = bstrArray.Detach();
return S_OK;
}
/*
* Converts the specified (reply) string into a Variant value.
* If the string contains tab characters ('\t), the string is
* considered to contain an array of values.
*/
CComVariant CMELCommand::MakeVariant(const CAtlString& strText)
{
int tabCount = 0;
int tabPos = 0;
while (tabPos < strText.GetLength()) {
tabPos = strText.Find(L'\t', tabPos);
if (tabPos < 0)
break;
++tabCount;
++tabPos;
}
if (!tabCount) {
return MakeVariantNotArray(strText);
}
CComSafeArray<VARIANT> safeArray;
safeArray.Create(tabCount + 1);
int curPos = 0;
int index = 0;
tabPos = strText.Find(L'\t');
for (;;) {
CAtlString strElement;
if (tabPos > curPos) {
strElement = strText.Mid(curPos, tabPos - curPos).Trim();
}
safeArray[index++] = MakeVariantNotArray(strElement);
curPos = tabPos + 1;
if (curPos == strText.GetLength()) {
safeArray[index] = CComVariant(L"");
break;
}
tabPos = strText.Find(L'\t', curPos);
if (tabPos < 0) {
safeArray[index] = MakeVariant(strText.Mid(curPos).Trim());
break;
}
}
return CComVariant(safeArray);
}
//----------------------------------------------------------------------------
//
HRESULT CAnchoRuntime::fireOnBeforeRequest(const std::wstring &aUrl, const std::wstring &aMethod, const CAnchoRuntime::FrameRecord *aFrameRecord, /*out*/ BeforeRequestInfo &aOutInfo)
{
CComPtr<ComSimpleJSObject> info;
IF_FAILED_RET(SimpleJSObject::createInstance(info));
fillRequestInfo(*info, aUrl, aMethod, aFrameRecord);
CComPtr<ComSimpleJSArray> argArray;
IF_FAILED_RET(SimpleJSArray::createInstance(argArray));
argArray->push_back(CComVariant(info.p));
CComVariant result;
m_pAnchoService->invokeEventObjectInAllExtensions(CComBSTR(L"webRequest.onBeforeRequest"), argArray.p, &result);
if (result.vt & VT_ARRAY) {
CComSafeArray<VARIANT> arr;
arr.Attach(result.parray);
//contained data already managed by CComSafeArray
VARIANT tmp = {0}; HRESULT hr = result.Detach(&tmp);
BEGIN_TRY_BLOCK
aOutInfo.cancel = false;
for (ULONG i = 0; i < arr.GetCount(); ++i) {
Ancho::Utils::JSObjectWrapperConst item = Ancho::Utils::JSValueWrapperConst(arr.GetAt(i)).toObject();
Ancho::Utils::JSValueWrapperConst cancel = item[L"cancel"];
if (!cancel.isNull()) {
aOutInfo.cancel = aOutInfo.cancel || cancel.toBool();
}
Ancho::Utils::JSValueWrapperConst redirectUrl = item[L"redirectUrl"];
if (!redirectUrl.isNull()) {
aOutInfo.redirect = true;
aOutInfo.newUrl = redirectUrl.toString();
}
}
END_TRY_BLOCK_CATCH_TO_HRESULT
}
bool XlLibraryInitialize(XlAddInExportInfo* pExportInfo)
{
HRESULT hr;
CComPtr<ICorRuntimeHost> pHost;
hr = LoadClr20(&pHost);
if (FAILED(hr) || pHost == NULL)
{
// LoadClr20 shows diagnostic MessageBoxes if needed.
// Perhaps remember that we are not loaded?
return 0;
}
// If all is fine now, also start the CLR (always safe to do again.
hr = pHost->Start();
if (FAILED(hr))
{
ShowMessage(IDS_MSG_HEADER_NEEDCLR20,
IDS_MSG_BODY_HOSTSTART,
IDS_MSG_FOOTER_UNEXPECTED,
hr);
return 0;
}
CString addInFullPath = AddInFullPath();
CPath xllDirectory(addInFullPath);
xllDirectory.RemoveFileSpec();
CComPtr<IUnknown> pAppDomainSetupUnk;
hr = pHost->CreateDomainSetup(&pAppDomainSetupUnk);
if (FAILED(hr) || pAppDomainSetupUnk == NULL)
{
ShowMessage(IDS_MSG_HEADER_APPDOMAIN,
IDS_MSG_BODY_APPDOMAINSETUP,
IDS_MSG_FOOTER_UNEXPECTED,
hr);
return 0;
}
CComQIPtr<IAppDomainSetup> pAppDomainSetup = pAppDomainSetupUnk;
hr = pAppDomainSetup->put_ApplicationBase(CComBSTR(xllDirectory));
if (FAILED(hr))
{
ShowMessage(IDS_MSG_HEADER_APPDOMAIN,
IDS_MSG_BODY_APPLICATIONBASE,
IDS_MSG_FOOTER_UNEXPECTED,
hr);
return 0;
}
CComBSTR configFileName = addInFullPath;
configFileName.Append(L".config");
pAppDomainSetup->put_ConfigurationFile(configFileName);
CComBSTR appDomainName = L"ExcelDna: ";
appDomainName.Append(addInFullPath);
pAppDomainSetup->put_ApplicationName(appDomainName);
IUnknown *pAppDomainUnk = NULL;
hr = pHost->CreateDomainEx(appDomainName, pAppDomainSetupUnk, 0, &pAppDomainUnk);
if (FAILED(hr) || pAppDomainUnk == NULL)
{
ShowMessage(IDS_MSG_HEADER_APPDOMAIN,
IDS_MSG_BODY_APPDOMAIN,
IDS_MSG_FOOTER_UNEXPECTED,
hr);
return 0;
}
CComQIPtr<_AppDomain> pAppDomain(pAppDomainUnk);
// Load plan for ExcelDna.Loader:
// Try AppDomain.Load with the name ExcelDna.Loader.
// Then if it does not work, we will try to load from a known resource in the .xll.
CComPtr<_Assembly> pExcelDnaLoaderAssembly;
hr = pAppDomain->Load_2(CComBSTR(L"ExcelDna.Loader"), &pExcelDnaLoaderAssembly);
if (FAILED(hr) || pExcelDnaLoaderAssembly == NULL)
{
HRSRC hResInfoLoader = FindResource(hModuleCurrent, L"EXCELDNA_LOADER", L"ASSEMBLY");
if (hResInfoLoader == NULL)
{
ShowMessage(IDS_MSG_HEADER_APPDOMAIN,
IDS_MSG_BODY_MISSINGEXCELDNALOADER,
IDS_MSG_FOOTER_UNEXPECTED,
hr);
return 0;
}
HGLOBAL hLoader = LoadResource(hModuleCurrent, hResInfoLoader);
void* pLoader = LockResource(hLoader);
ULONG sizeLoader = (ULONG)SizeofResource(hModuleCurrent, hResInfoLoader);
CComSafeArray<BYTE> bytesLoader;
bytesLoader.Add(sizeLoader, (byte*)pLoader);
hr = pAppDomain->Load_3(bytesLoader, &pExcelDnaLoaderAssembly);
if (FAILED(hr))
{
ShowMessage(IDS_MSG_HEADER_APPDOMAIN,
IDS_MSG_BODY_EXCELDNALOADER,
IDS_MSG_FOOTER_UNEXPECTED,
hr);
return 0;
}
CComBSTR pFullName;
hr = pExcelDnaLoaderAssembly->get_FullName(&pFullName);
if (FAILED(hr))
{
ShowMessage(IDS_MSG_HEADER_APPDOMAIN,
IDS_MSG_BODY_EXCELDNALOADERNAME,
IDS_MSG_FOOTER_UNEXPECTED,
hr);
return 0;
}
}
CComPtr<_Type> pXlAddInType;
hr = pExcelDnaLoaderAssembly->GetType_2(CComBSTR(L"ExcelDna.Loader.XlAddIn"), &pXlAddInType);
if (FAILED(hr) || pXlAddInType == NULL)
{
ShowMessage(IDS_MSG_HEADER_APPDOMAIN,
IDS_MSG_BODY_XLADDIN,
IDS_MSG_FOOTER_UNEXPECTED,
hr);
return 0;
}
CComSafeArray<VARIANT> initArgs;
initArgs.Add(CComVariant((INT32)pExportInfo));
initArgs.Add(CComVariant((INT32)hModuleCurrent));
initArgs.Add(CComVariant(addInFullPath.AllocSysString()));
CComVariant initRetVal;
CComVariant target;
hr = pXlAddInType->InvokeMember_3(CComBSTR("Initialize"), (BindingFlags)(BindingFlags_Static | BindingFlags_Public | BindingFlags_InvokeMethod), NULL, target, initArgs, &initRetVal);
if (FAILED(hr))
{
ShowMessage(IDS_MSG_HEADER_APPDOMAIN,
IDS_MSG_BODY_XLADDININIT,
IDS_MSG_FOOTER_UNEXPECTED,
hr);
return 0;
}
pHost_ForUnload = pHost.Detach();
pAppDomain_ForUnload = (IUnknown*)pAppDomain.Detach();
return initRetVal.boolVal == 0 ? false : true;
}
STDMETHODIMP CConsoleObject::BstrPrintf(BSTR* ret, const SAFEARRAY& varg) const
{
//DUMP_VARIANTSAFEARRAY(&varg);
if (ret == NULL)
return E_POINTER;
CComSafeArray<VARIANT> safearray;
HRESULT hr = safearray.Attach(&varg);
if (FAILED(hr)) return hr;
if (safearray.GetDimensions() != 1)
return E_INVALIDARG;
CAtlString result(_T(""));
_variant_t current;
int upper = safearray.GetUpperBound() + 1;
for (int i = safearray.GetLowerBound(); i < upper; i++) {
current.Attach(safearray[i]);
if (current.vt == VT_I4) {
result.AppendFormat(_T("%ld"), current.lVal);
} else if (current.vt == VT_BSTR) {
_bstr_t str(current.bstrVal);
int specCount = 0;
TCHAR* lastFound = str;
TCHAR* found;
TCHAR next;
int specLength = 0;
found = _tcschr(str, _T('%'));
if (found == NULL) {
result += static_cast<TCHAR*>(str);
} else {
while (found) {
next = *(found + 1);
switch (next) {
case _T('%') : {
specLength = 2;
result.CopyChars(result.GetBuffer(), lastFound,
static_cast<int>(found + 1 - lastFound));
}
case _T('s') : {
specLength = 2;
_variant_t varstr;
GET_NEXT_VARIANT(varstr, VT_BSTR);
result.Append(lastFound, static_cast<int>(found - lastFound));
result += varstr.bstrVal;
break;
}
case _T('d') : {
specLength = 2;
_variant_t varint;
GET_NEXT_VARIANT(varint, VT_I4);
result.Append(lastFound, static_cast<int>(found - lastFound));
result.AppendFormat(_T("%ld"), varint.lVal);
break;
}
case _T('f') : {
specLength = 2;
//GET_NEXT_VARIANT(VT_R8);
break;
}
case _T('x') :
break;
default:
break;
}
found += specLength;
lastFound = found;
found = _tcschr(found, _T('%'));
} // while loop
}
} else {
result += _T("[unsupported argument type]");
}
result += _T(' ');
current.Detach();
} // for loop
safearray.Detach();
result.SetAt(result.GetLength() - 1, _T('\0'));
BSTR tmp = result.AllocSysString();
if (tmp == NULL) return E_OUTOFMEMORY;
*ret = tmp;
return S_OK;
}
void main(int argc, char**argv)
{
std::wcout << L"\n ===================================\n";
std::wcout << L"\n TextFinderComponent C++ Interface ";
std::wcout << L"\n ===================================\n";
HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
if (!SUCCEEDED(hr))
{
std::wcout << L"\n could not initialize COM";
}
try
{
CComQIPtr<ITextCompCOM> TextFinderComp;
TextFinderComp.CoCreateInstance(CLSID_TextCompCOM);
if (TextFinderComp != 0)
{
std::wcout << L"\n =============================================================\n";
std::wcout << "The Text Component Interface was successfully initialized" << std::endl;
std::wcout << L"\n =============================================================\n";
InputArgumentParser parser;
if (parser.parseCommandLineArgs2TextCompArguments(argc, argv))
{
HRESULT h0 = TextFinderComp->InitializeComponent();
HRESULT h1 = TextFinderComp->SetSearchPath(CComBSTR(parser.getDirectoryPath().c_str()));
BSTR allPatterns;
BSTR recursion;
allPatterns = convertstdSTR2BSTR(bool2String(true)) ; //By default find all patterns
recursion = convertstdSTR2BSTR(bool2String(false)) ; // By default Recursion is disabled
if (parser.getRecursionFlag())
{
recursion = convertstdSTR2BSTR(bool2String(true));
}
if (!parser.getAllPatternsFlag())
{
allPatterns = convertstdSTR2BSTR(bool2String(false));
}
HRESULT h2 = TextFinderComp->SetSpecialSearchClause(recursion, allPatterns);
HRESULT h3 = TextFinderComp->SetFilePatterns(convertVector2CCOMSafeArray(parser.getFilePatterns()).GetSafeArrayPtr());
HRESULT h4 = TextFinderComp->SetTextPatterns(convertVector2CCOMSafeArray(parser.getTextPatterns()).GetSafeArrayPtr());
if (SUCCEEDED(h0) && SUCCEEDED(h1) && SUCCEEDED(h2) && SUCCEEDED(h3) && SUCCEEDED(h4))
{
SAFEARRAY files;
SAFEARRAY* pFiles = &files;
TextFinderComp->GetQualifyingFileList(&pFiles);
CComSafeArray<BSTR> Files;
Files.Attach(pFiles);
std::wcout << L"\n =============================================================\n";
std::wcout << L"\n =============================================================\n";
std::wcout<<"The Qualifying Files from the Text Search Component via C++ COM interface"<<std::endl;
displayCCOMBSTRFiles(Files);
std::cout << "End of C++ Client for Text Search Component" << std::endl;
std::wcout << L"\n =============================================================\n";
}
}
else
{
parser.displayIllegalArgumentMessage();
}
}
}
catch (std::exception& ex)
{
std::wcout << L"\n Exception Encountered during COM Stuff .. Contact Admin and Bug Him!" << ex.what() << L"\n\n";
return;
}
std::wcout << L"\n\n";
CoUninitialize();
}
LRESULT CChildFrame::OnTvnSelChanged(int idCtrl, LPNMHDR pNMHDR, BOOL& bHandled)
{
USES_CONVERSION;
HRESULT hr = E_FAIL;
idCtrl, pNMHDR, bHandled;
CTreeViewCtrl ctrlTree = m_wndCatalog;
bHandled = FALSE;
NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
ATLASSERT( pNMTreeView );
{
m_pData.m_hTreeItem = pNMTreeView->itemNew.hItem;
m_pData.m_pTreeView = &m_wndCatalog;
}
CTreeItem hItem(pNMTreeView->itemNew.hItem, &m_wndCatalog);
TREE_ITEM_DATA * pCurrSel = NULL;
pCurrSel = (TREE_ITEM_DATA *) ctrlTree.GetItemData(hItem);
if (pCurrSel && STGTY_STREAM == pCurrSel->dwStgType)
{
CComPtr<IStream> spStrm;
hr = pCurrSel->spStgOrStrm->QueryInterface(&spStrm);
if (FAILED(hr)) return hr;
STATSTG st = { 0 };
hr = spStrm->Stat(&st, STATFLAG_NONAME);
if (FAILED(hr)) return hr;
LARGE_INTEGER liBegin = { 0 };
hr = spStrm->Seek(liBegin, STREAM_SEEK_SET, NULL);
BYTE * byBuff = new BYTE[st.cbSize.QuadPart+1];
ZeroMemory(byBuff, (st.cbSize.QuadPart+1)*sizeof(BYTE));
ULONG ulSize = 0;
hr = spStrm->Read(byBuff, st.cbSize.QuadPart, &ulSize);
ATLASSERT(SUCCEEDED(hr));
if(st.cbSize.QuadPart)
{
CComSafeArray data;
data.CreateOneDim(VT_UI1, st.cbSize.QuadPart, (const void *)byBuff);
m_wndHexEdit.SetData(data);
}
else
{
CComVariant data;
m_wndHexEdit.SetData(data);
}
{
m_wndFileDetails.ShowWindow(SW_HIDE);
m_wndHexEdit.ShowWindow(SW_NORMAL);
SetSplitterPane(SPLIT_PANE_RIGHT, m_wndHexEdit);
}
delete [] byBuff;
}
else if (pCurrSel && STGTY_STORAGE == pCurrSel->dwStgType)
{
CComVariant data;
m_wndHexEdit.SetData(data);
m_wndHexEdit.ShowWindow(SW_HIDE);
std::vector<STATSTG_EX> vecFileInfo;
CTreeItem tiChild = hItem.GetChild();
while (FALSE == tiChild.IsNull())
{
TREE_ITEM_DATA * pData = (TREE_ITEM_DATA *)tiChild.GetData();
STATSTG_EX statstgex;
do
{
if (pData->dwStgType == STGTY_STREAM)
{
CComPtr<IStream> spStrm;
hr = pData->spStgOrStrm->QueryInterface(&spStrm);
if (FAILED(hr)) break;
hr = spStrm->Stat(&statstgex, STATFLAG_NONAME);
if (FAILED(hr)) break;
}
else if (pData->dwStgType == STGTY_STORAGE)
{
CComPtr<IStorage> spStg;
hr = pData->spStgOrStrm->QueryInterface(&spStg);
if (FAILED(hr)) break;
hr = spStg->Stat(&statstgex, STATFLAG_NONAME);
if (FAILED(hr)) break;
}
} while(0);
statstgex.htiHost = tiChild.m_hTreeItem;
TCHAR szSwap[MAX_PATH] = { 0 };
tiChild.GetText(szSwap, _countof(szSwap));
TCHAR2WCHAR(szSwap, statstgex.szwName, _countof(statstgex.szwName));
vecFileInfo.push_back(statstgex);
tiChild = tiChild.GetNextSibling();
}
m_wndFileDetails.SetFileInfo(vecFileInfo);
m_wndFileDetails.ShowWindow(SW_NORMAL);
SetSplitterPane(SPLIT_PANE_RIGHT, m_wndFileDetails);
}
return 0;
}
