//This is used to get the value for an element in a group.
//The element is identified by the dwCookie parameter
STDMETHODIMP CComPolygon::GetElementValue(
/* [in] */ DISPID dispID,
/* [in] */ DWORD dwCookie,
/* [out] */ VARIANT * pVarOut)
{
CHECKOUTPARAM(pVarOut);
if (dispID >= DISPID_NORMAL && dispID <= DISPID_STARTPOINT)
{
try
{
if (dwCookie>2)
throw Acad::eInvalidInput;
Acad::ErrorStatus es;
AcAxObjectRefPtr<AsdkPoly> pPoly(&m_objRef,AcDb::kForRead,Adesk::kTrue);
if((es=pPoly.openStatus()) != Acad::eOk)
throw es;
AcAxPoint3d pt;
Adesk::Boolean bAsVector=Adesk::kFalse;
if (dispID == DISPID_NORMAL)
{
pt = pPoly->normal();
//translate from wcs to ucs
acdbWcs2Ucs(asDblArray(pt),asDblArray(pt),Adesk::kTrue);
::VariantCopy(pVarOut,&CComVariant(pt[dwCookie]));
} else {
AcAxPoint2d pt2d;
switch (dispID)
{
case DISPID_CENTER:
pt2d = pPoly->center();
break;
case DISPID_STARTPOINT:
pt2d = pPoly->startPoint();
break;
default:
throw Acad::eInvalidInput;
}
pt.set(pt2d.x,pt2d.y,pPoly->elevation());
//translate from wcs to ucs
acdbEcs2Ucs(asDblArray(pt),asDblArray(pt),asDblArray(pPoly->normal()),Adesk::kFalse);
::VariantCopy(pVarOut,&CComVariant(pt[dwCookie]));
}
}
catch(const Acad::ErrorStatus)
{
return Error(L"Failed to open object",IID_IComPolygon,E_FAIL);
}
catch(const HRESULT hr)
{
return Error(L"Invalid argument.",IID_IComPolygon,hr);
}
}
return S_OK;
}
void WebHandler::GetChatMessage()
{
CComQIPtr<IHTMLElementCollection> allElements;
HRESULT hr = S_FALSE;
//hr = htmlDocument_->get_all(&allElements); //取得表单集合
//if (FAILED(hr))
// return;
CComQIPtr<IHTMLElementCollection> scrpitsCollection;
htmlDocument_->get_scripts(&scrpitsCollection);
if (FAILED(hr))
return;
long nItemCount = 0; //取得表单数目
hr = scrpitsCollection->get_length(&nItemCount);
if (FAILED(hr))
return;
BSTR pstr = SysAllocString(L"");;
hr = scrpitsCollection->toString(&pstr);
if (FAILED(hr))
return;
for (long i = 0; i < nItemCount; i++)
{
CComDispatchDriver spDisp; //取得第 j 项表单域
hr = scrpitsCollection->item(CComVariant(i), CComVariant(), &spDisp);
if (FAILED(hr))
continue;
CComQIPtr<IHTMLElement> spElement = spDisp;
if (!spElement)
break;
CComBSTR className;
std::wstring compareStr;
hr = spElement->get_className(&className);
if (FAILED(hr))
continue;
if (className)
{
compareStr = (LPCTSTR)className;
}
}
// 未成功
//DISPID dispid;
//OLECHAR FAR* funcName = L"click";
//CComBSTR funNameStr(funcName);
//hr = scrpitsCollection->GetIDsOfNames(IID_NULL, &funNameStr, 1, LOCALE_SYSTEM_DEFAULT, &dispid);
//if (FAILED(hr))
// return;
}
//5386 pin
int PinOrUnpinCmd(int iResIndex)
{
char szPath[MAX_PATH];
if(!CLhcImg::GetHomePath(szPath, MAX_PATH))
return 0;
string strDirPath = string(szPath);
if (strDirPath.empty())
return 0;
string strFileName = "PlayBox.exe";
HMODULE hShell32 = ::LoadLibrary("shell32.dll");
if (!hShell32)
return 1;
char szCmd[512];
int nLen = ::LoadString(hShell32, iResIndex, szCmd, 512);
::CoInitialize(NULL);
CComPtr<IShellDispatch> pShell;
if (FAILED(::CoCreateInstance(CLSID_Shell, NULL, CLSCTX_SERVER, IID_IDispatch, (LPVOID*)&pShell)) || !pShell)
return 1;
CComPtr<Folder> pFolder;
if (FAILED(pShell->NameSpace(CComVariant(strDirPath.c_str()), &pFolder)) || !pFolder)
return 1;
CComPtr<FolderItem> pItem;
if (FAILED(pFolder->ParseName(CComBSTR(strFileName.c_str()), &pItem)) || !pItem)
return 1;
CComPtr<FolderItemVerbs> pItemVerbs;
if (FAILED(pItem->Verbs(&pItemVerbs)) || !pItemVerbs)
return 1;
long lCount = 0;
pItemVerbs->get_Count(&lCount);
for (long i = 0; i < lCount; i++)
{
CComPtr<FolderItemVerb> pItemVerb;
pItemVerbs->Item(CComVariant(i), &pItemVerb);
if (pItemVerb)
{
CComBSTR bstrName;
pItemVerb->get_Name(&bstrName);
if (bstrName == szCmd)
{
pItemVerb->DoIt();
return 0;
}
}
}
return 0;
}
STDMETHODIMP CFoundationExemplars::TMchOnCreate(IThing* pThing)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState())
CComPtr<IThing> pThis;
HRESULT hr;
if (FAILED(hr = m_pWorld->get_This(&pThis)))
goto ERROR_ENCOUNTERED;
if (pThis)
{
//Create a display and set the TransactionMachine.Display to it
CComPtr<IThing> pDisplay;
CComPtr<IVWGeometry> pGeometry;
CComPtr<IThing> pPrevBtn;
CComPtr<IThing> pNextBtn;
CComPtr<IThing> pSelectBtn;
if (FAILED(hr = m_pWorld->CreateInstanceExt(CComBSTR("Display"),
CComVariant(CComBSTR("Display")), pThis,
&pDisplay)))
goto ERROR_ENCOUNTERED;
if (FAILED(hr = pThis->put_ObjectProperty(CComBSTR("Display"), (IObjectProperty*) pDisplay)))
goto ERROR_ENCOUNTERED;
// Add buttons to contents
if (FAILED(hr = m_pWorld->CreateInstanceExt(CComBSTR("PreviousButton"),
CComVariant(CComBSTR("PreviousButton")), pThis,
&pPrevBtn)))
goto ERROR_ENCOUNTERED;
if (FAILED(hr = m_pWorld->CreateInstanceExt(CComBSTR("NextButton"),
CComVariant(CComBSTR("NextButton")), pThis,
&pNextBtn)))
goto ERROR_ENCOUNTERED;
if (FAILED(hr = m_pWorld->CreateInstanceExt(CComBSTR("SelectButton"),
CComVariant(CComBSTR("SelectButton")), pThis,
&pSelectBtn)))
goto ERROR_ENCOUNTERED;
}
return S_OK;
ERROR_ENCOUNTERED:
VWTRACE(m_pWorld, "VWFOUND", VWT_ERROR, "CFoundationExemplars::TMchOnCreate Error %x", hr);
return hr;
}
HRESULT CAzRole::Copy(CAzRole &srcRole) {
CAzLogging::Entering(_TEXT("CAzRole::Copy"));
CComBSTR bstrData;
HRESULT hr=m_native->Submit(0,CComVariant());
CAzLogging::Log(hr,_TEXT("Submitting for role"),COLE2T(getName()));
if (FAILED(hr))
goto lError1;
hr=srcRole.m_native->get_Description(&bstrData);
CAzLogging::Log(hr,_TEXT("Getting Description for role"),COLE2T(getName()));
if (SUCCEEDED(hr)) {
hr=m_native->put_Description(bstrData);
CAzLogging::Log(hr,_TEXT("Setting Description for role"),COLE2T(getName()));
bstrData.Empty();
}
hr=srcRole.m_native->get_ApplicationData(&bstrData);
CAzLogging::Log(hr,_TEXT("Getting ApplicationData for role"),COLE2T(getName()));
if (SUCCEEDED(hr)) {
hr=m_native->put_ApplicationData(bstrData);
CAzLogging::Log(hr,_TEXT("Setting ApplicationData for role"),COLE2T(getName()));
}
hr=CopyUserData(srcRole);
CAzLogging::Log(hr,_TEXT("CopyUserData for role"),COLE2T(getName()));
hr=m_native->Submit(0,CComVariant());
CAzLogging::Log(hr,_TEXT("Submitting for role"),COLE2T(getName()));
lError1:
CAzLogging::Exiting(_TEXT("CAzRole::Copy"));
return hr;
}
//----------------------------------------------------------------------------
// RunModule
HRESULT CMagpieActiveScript::RunModule(
CMagpieModule* pModule)
{
CComPtr<IDispatch> pModuleRequireOb(pModule->GetRequire());
if (!pModuleRequireOb)
{
return E_UNEXPECTED;
}
CString sFilename, sModuleID;
pModule->GetID(sModuleID);
pModule->GetFilename(sFilename);
m_ScriptEngine->SetScriptState(SCRIPTSTATE_DISCONNECTED);
// add namespace for module
IF_FAILED_RET(m_ScriptEngine->AddNamedItem(sModuleID, SCRIPTITEM_CODEONLY));
// dispatch for module's namespace
CIDispatchHelper script;
IF_FAILED_RET(m_ScriptEngine->GetScriptDispatch(sModuleID, &script));
// create exports object
CIDispatchHelper scriptGlobal;
IF_FAILED_RET(m_ScriptEngine->GetScriptDispatch(NULL, &scriptGlobal));
CComPtr<IDispatch> pModuleExportsOb;
IF_FAILED_RET(scriptGlobal.CreateObject(L"Object", &pModuleExportsOb));
// inject CommonJS objects
script.SetPropertyByRef(L"require", CComVariant(pModuleRequireOb));
script.SetPropertyByRef(L"module", CComVariant(pModule));
script.SetPropertyByRef(L"exports", CComVariant(pModuleExportsOb));
CComVariant vtSalsita;
HRESULT hr = GetSalsitaObject(&vtSalsita);
if (SUCCEEDED(hr))
{
script.SetPropertyByRef(L"salsita", vtSalsita);
}
// now run the module
m_Application.EnterModule(sModuleID);
hr = LoadScriptFile(sFilename, sModuleID);
if (SUCCEEDED(hr))
{
m_ScriptEngine->SetScriptState(SCRIPTSTATE_CONNECTED);
}
m_Application.ExitModule();
return S_OK;
}
HRESULT CbDevice::EnableSwClocking()
{
double maxRate, minRate;
//
// It is possible that the hardware will not have the same capabilities as our software clocking
// In this case we must adjust our assumptions as to what the MIN and MAX sampling rates
// should be.
//
// Decide the true maximum sampling rate
if(_maxSampleRate < MAX_SW_SAMPLERATE)
maxRate = _maxSampleRate;
else
maxRate = MAX_SW_SAMPLERATE;
// Decide the true minimum sampling rate
if(_minSampleRate > MIN_SW_SAMPLERATE)
minRate = _minSampleRate;
else
minRate = MIN_SW_SAMPLERATE;
RETURN_HRESULT(pSampleRate.SetRange(minRate, maxRate));
// Set the default rate to 1/5 the max rate
double defaultRate = int(maxRate/5);
pSampleRate.SetDefaultValue(defaultRate);
// Range check the existing sample rate
if (pSampleRate>maxRate)
{
pSampleRate=maxRate;
}
else if (pSampleRate<minRate)
{
pSampleRate=minRate;
}
// If this HW only supports SW Clocking then set the sample rate to the default
if ( _ClockingType == SOFTWARE )
{
pSampleRate = defaultRate;
}
pSampleRate=RoundRate(pSampleRate);
RETURN_HRESULT(_DaqHwInfo->put_MemberValue(L"minsamplerate", CComVariant(minRate)));
RETURN_HRESULT(_DaqHwInfo->put_MemberValue(L"maxsamplerate", CComVariant(maxRate)));
return S_OK;
}
void SysStatsApp::close(SysStatsClientWindow *window)
{
getShellMenu()->removeSubMenu(window->getContextMenu());
int pos = windows.find(window);
if (pos > -1)
{
saveTheme();
IClientModel *pModel;
models.Item(CComVariant(pos), &pModel);
models.Remove(CComVariant(pos));
pModel->Release();
delete windows.remove(pos);
}
}
HRESULT CbDevice::SetClockSource()
{
if (_UseSoftwareClock)
{
return EnableSwClocking();
}
else
{
RETURN_HRESULT(_DaqHwInfo->put_MemberValue(L"minsamplerate", CComVariant(_minSampleRate)));
RETURN_HRESULT(_DaqHwInfo->put_MemberValue(L"maxsamplerate", CComVariant(_maxSampleRate)));
pSampleRate.SetRange(_minSampleRate,_maxSampleRate);
UpdateRateAndSkew();
}
return S_OK;
}
void EnumEmbeds(IHTMLDocument2 *pIHTMLDocument2)
{
if(!pIHTMLDocument2) return;
HRESULT hr;
USES_CONVERSION;
CComPtr< IHTMLElementCollection > spEmbedCollection;
hr = pIHTMLDocument2->get_embeds(&spEmbedCollection); //取得Embed的集合
if (FAILED(hr))
{
cout << _T("错误: 获取Embed集合IHTMLElementCollection!") << endl;
return;
}
long nEmbedCount = 0; //取得Embed个数
hr = spEmbedCollection->get_length(&nEmbedCount);
if (FAILED(hr))
{
cout << _T("错误: 获取Embed集合IHTMLElementCollection的长度!") << endl;
}
cout << "Embed对象共: " << nEmbedCount << endl;
CComBSTR bstrPluginsPage, bstrSrc;
IDispatch *pDisp = NULL;
CComQIPtr< IHTMLEmbedElement > spEmbedElement;
for(long i = 0; i < nEmbedCount; i++)
{
hr = spEmbedCollection->item(CComVariant(i), CComVariant(), &pDisp);
if (FAILED(hr) || !pDisp) continue;
spEmbedElement = pDisp;
pDisp->Release();
spEmbedElement->get_pluginspage(&bstrPluginsPage);
spEmbedElement->get_src(&bstrSrc);
cout << i + 1
<< ": pluginspage = " << (bstrPluginsPage ? OLE2CT(bstrPluginsPage) : _T(""))
<< ", src = " << (bstrSrc ? OLE2CT(bstrSrc) : _T(""))
<< endl;
}
if (pDisp)
{
pDisp->Release();
pDisp = NULL;
}
}
STDMETHODIMP CISEMMManager::CancelLastMmQuote(VARIANT vtParams)
{
_EventTypeEnum Type = _enRequestLastQuote;
CMMQuoteParams Request;
if(CComVariant(vtParams) != vtMissing)
{
try
{
_ISEMMQuoteParams Params(vtParams);
Request.m_sSymbol = (char*)_bstr_t(Params->Symbol);
if(Request.m_sSymbol.length() == 0)
return Error(L"Invalid symbol name.");
Request.m_Type = Params->Type;
Request.m_BidOrAsk = Params->BidOrAsk;
}
catch(_com_error& e)
{
return e.Error();
}
}
return ((CMMManagerPriceObject*)theISEManager)->RemoveRequest(this, Request, _enRequestLastOption);
}
/**
* Method: NativeMessaging::tabs_active
*
* @param uuid
*
* @returns Tab
*/
STDMETHODIMP CNativeMessaging::tabs_active(BSTR uuid, IDispatch *callback, UINT *out_tabId)
{
HRESULT hr = S_OK;
CComPtr<ITypeInfo> tabT = nullptr;
CComPtr<IUnknown> tabI = nullptr;
for (;;) {
BreakOnNull(out_tabId, hr);
*out_tabId = m_activeTab.id;
BreakOnNull(callback, hr);
hr = ::CreateDispTypeInfo(&Tab::Interface, LOCALE_SYSTEM_DEFAULT, &tabT);
BreakOnFailed(hr);
BreakOnNull(tabT, hr);
hr = ::CreateStdDispatch(NULL, &m_activeTab, tabT, &tabI);
BreakOnFailed(hr);
BreakOnNull(tabI, hr);
hr = CComDispatchDriver(callback).Invoke1((DISPID)0, &CComVariant(tabI));
break;
}
if (FAILED(hr))
logger->error(L"CNativeMessaging::tabs_active failed -> " + logger->parse(hr));
return hr;
}
HRESULT _AddMapKey(IWorld *pWorld, IAvatarProfile *pProfile, BSTR bstrKey, IThing *pOwner)
{
HRESULT hr = S_OK;
IPropertyMap *pMap = NULL;
hr = CreatePropertyMap(pWorld, &pMap);
if (FAILED(hr))
goto CLEAN_UP;
hr = pProfile->AddKey(bstrKey, CComVariant(pMap), kVarNone, CComVariant(kKeyPublic), CComVariant(pOwner));
CLEAN_UP:
SAFERELEASE(pMap);
return hr;
}
LRESULT PickList<C>::init(HWND hDlg, WORD wId, ICompositeOverlay *overlays, C curVal)
{
this->hDlg = hDlg;
this->wId = wId;
BSTR s;
short count;
overlays->Count(&count);
int index = SendDlgItemMessage(hDlg,wId,CB_ADDSTRING,0,(LPARAM)"(none)");
SendDlgItemMessage(hDlg,wId,CB_SETITEMDATA,index,(LPARAM)-1);
if ((*pEquals)(curVal,-1))
SendDlgItemMessage(hDlg,wId,CB_SETCURSEL,(WPARAM)index,0);
for (int i=0; i<count; i++)
{
IOverlay *overlay;
overlays->Item(CComVariant(i), &overlay);
overlay->get_Name(&s);
index = SendDlgItemMessage(hDlg,wId,CB_ADDSTRING,0,(LPARAM)((char*)_bstr_t(s, false)));
SendDlgItemMessage(hDlg,wId,CB_SETITEMDATA,index,(LPARAM)i);
if ((*pEquals)(curVal,i))
SendDlgItemMessage(hDlg,wId,CB_SETCURSEL,(WPARAM)index,0);
overlay->Release();
}
return 1;
}
STDMETHODIMP CMyComX::IsValid(VARIANT_BOOL *ret)
{
// 現在時間から適当に TRUE/FALSE を戻す
*ret = CComVariant((GetTickCount() % 2) ? true : false).boolVal;
return S_OK;
}
bool AddXMLAttribute(CComPtr<IXMLDOMNode> node, const TCHAR * name, const TCHAR * value)
{
CComQIPtr<IXMLDOMElement> element;
element = node;
element->setAttribute(CComBSTR(name), CComVariant(value));
return true;
}
STDMETHODIMP CFoundationExemplars::TMchNextButton_OnLButtonDown(long hWnd, long x, long y)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState())
CComPtr<IThing> pThis;
CComPtr<IThing> pContainer;
HRESULT hr;
//Get container (the transaction machine) and call method to update current index
if (FAILED(hr = m_pWorld->get_This(&pThis)))
goto ERROR_ENCOUNTERED;
if (pThis)
{
if (FAILED(hr = pThis->get_Container(&pContainer)))
goto ERROR_ENCOUNTERED;
}
if (pContainer)
{
if (FAILED(hr = pContainer->InvokeMethodExt(CComBSTR("UpdateCurrentIndex"),
CComDISPPARAMS(1, CComVariant(1L)), NULL)))
goto ERROR_ENCOUNTERED;
}
return S_OK;
ERROR_ENCOUNTERED:
VWTRACE(m_pWorld, "VWFOUND", VWT_ERROR, "CFoundationExemplars::TMchPreviousButton_OnLButtonDown Error %x\n", hr);
return hr;
}
void CPagePlayers::SectorOrTeamChange(IAGCEvent* pEvent, int iColumn,
LPCOLESTR pszProperty)
{
CWaitCursor wait;
// Get the interesting properties of the event
CComBSTR bstrName, bstrProperty;
pEvent->get_SubjectName(&bstrName);
CComVariant varNewPropertyName;
pEvent->get_Property(&CComVariant(pszProperty), &varNewPropertyName);
varNewPropertyName.ChangeType(VT_BSTR);
bstrProperty = V_BSTR(&varNewPropertyName);
// Name must not be empty
_ASSERTE(bstrName.Length());
// Find the list item with the specified name
USES_CONVERSION;
LV_FINDINFO lvfi = {LVFI_STRING, OLE2CT(bstrName)};
int iIndex = m_listPlayers.FindItem(&lvfi);
_ASSERTE(iIndex >= 0);
// Change the sub-item of the list item
m_listPlayers.SetItemText(iIndex, iColumn,
bstrProperty.Length() ? OLE2CT(bstrProperty) : TEXT(""));
}
void CPagePlayers::TeamInfoChange(IAGCEvent* pEvent)
{
CWaitCursor wait;
// Get the interesting properties of the event
CComBSTR bstrTeam, bstrTeamNew;
pEvent->get_SubjectName(&bstrTeam);
CComVariant varTeamNew;
pEvent->get_Property(&CComVariant(L"NewTeamName"), &varTeamNew);
varTeamNew.ChangeType(VT_BSTR);
CString strTeam(bstrTeam), strTeamNew(V_BSTR(&varTeamNew));
// Name must not be empty
_ASSERTE(!strTeam.IsEmpty());
// Loop through each item in the list
int cPlayers = m_listPlayers.GetItemCount();
for (int i = 0; i < cPlayers; ++i)
{
// Get the list item's team name
CString str(m_listPlayers.GetItemText(i, c_iColumnTeam));
// Change the team name of this item, if it has the old team name
if (str == strTeam)
m_listPlayers.SetItemText(i, c_iColumnTeam, strTeamNew);
}
}
STDMETHODIMP CompositeOverlayImpl<B>::Item(VARIANT index, IOverlay **pRet)
{
BSTR bstr;
short count = 0;
if (SUCCEEDED(SysStatsUtils::VariantToBSTR(&index, &bstr)))
{
Count(&count);
for (int i=0; i < count; i++)
{
IOverlay *pOverlay;
ArrayPtrVariant<IOverlay, SimpleOverlayImpl2<B> >::Item(CComVariant(i), &pOverlay);
BSTR name;
pOverlay->get_Name(&name);
if (wcscmp(name, bstr) == 0)
{
*pRet = pOverlay;
::SysFreeString(name);
return S_OK;
}
::SysFreeString(name);
pOverlay->Release();
}
return S_OK;
}
else
return ArrayPtrVariant<IOverlay, SimpleOverlayImpl2<B> >::Item(index, pRet);
/*return E_INVALIDARG;*/
}
/******************************************************************************
Function Name : FormatDOMDocument
Input(s) : MSXML2::IXMLDOMDocumentPtr pDoc
CString& omstrFilePath
Output : bool
Functionality : Formats the pDoc Pointer into File omStrFilePath
Member of : CTestSetupEntity
Friend of : -
Author(s) : Venkatanarayana Makam
Date Created : 06/04/2011
Modifications :
******************************************************************************/
BOOL CTestSetupEntity::FormatDOMDocument(MSXML2::IXMLDOMDocumentPtr pDoc, CString& omstrFilePath)
{
//Referance Taken From Msdn
MSXML2::ISAXXMLReaderPtr pSaxXmlReader = NULL;
pSaxXmlReader.CreateInstance(L"Msxml2.SAXXMLReader");
CComPtr<IStream> pStream;
DWORD grfMode = STGM_WRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE;
//W4 Removal
if(SHCreateStreamOnFile ((LPCTSTR)omstrFilePath, grfMode, &pStream) == S_OK)
{
MSXML2::IMXWriterPtr pImxWriter;
pImxWriter.CreateInstance (L"Msxml2.MXXMLWriter");
pImxWriter->put_output (CComVariant(pStream));
pSaxXmlReader->putContentHandler((MSXML2::ISAXContentHandlerPtr)pImxWriter);
pSaxXmlReader->putErrorHandler((MSXML2::ISAXErrorHandlerPtr)pImxWriter);
pSaxXmlReader->putDTDHandler((MSXML2::ISAXDTDHandlerPtr)pImxWriter);
pImxWriter->put_byteOrderMark(VARIANT_TRUE);
pImxWriter->put_indent(VARIANT_TRUE);
//W4 Removal
pSaxXmlReader->parse((_variant_t)(pDoc.GetInterfacePtr()));
pImxWriter->flush ();
return TRUE;
}
else
{
return FALSE;
}
}
void SysStatsApp::save()
{
BSTR path;
appConfig->CanonicalPath(INI, &path);
_bstr_t path_t = path;
char *appConfigFile = path_t;
// Clear the skin file of all the crap
int fd = _open(appConfigFile, _O_CREAT | _O_TRUNC | O_RDWR, _S_IWRITE);
_close(fd);
char val[32];
WritePrivateProfileString(GENERAL, CLIENT_COUNT_PROPERTY, itoa(windows.count(), val, 10), appConfigFile);
char name[64];
strcpy(name, CLIENT_PREFIX);
int offset = strlen(name);
for (int i=0; i<windows.count(); i++)
{
itoa(i, name+offset, 10);
windows[i]->save(appConfigFile, name);
IClientModel *pModel;
models.Item(CComVariant(i), &pModel);
pModel->Save(/* not interactive */ false);
BSTR cf;
pModel->get_ConfigFile(&cf);
BSTR ncf;
appConfig->NormalizePath(cf, &ncf);
::SysFreeString(cf);
WritePrivateProfileString(name, CONFIG_FILE_PROPERTY, _bstr_t(ncf, false), appConfigFile);
pModel->Release();
}
}
CA_API UINT __stdcall Xml_DeleteNodes(MSIHANDLE hInstall)
{
MSI_EXCEPTION_HANDLER_PROLOG;
MsiInstall msiInstall(hInstall);
std::wstring filename = msiInstall.GetProperty(L"XML_FILENAME");
AppSecInc::Xml::XmlDocument doc;
doc.Load(filename);
std::wstring xpath = msiInstall.GetProperty(L"XML_XPATH");
MSXML2::IXMLDOMNodeListPtr nodes = doc.FindNodes(xpath);
int count = 0;
if (NULL != nodes)
{
MSXML2::IXMLDOMNodePtr node = NULL;
while (NULL != (node = nodes->nextNode()))
{
node->parentNode->removeChild(node);
count++;
}
}
if (count > 0)
{
CHECK_HR(doc->save(CComVariant(filename.c_str())),
L"Error saving '" << filename << L"'");
}
msiInstall.SetProperty(L"XML_DELETED", AppSecInc::StringUtils::toWString(count));
MSI_EXCEPTION_HANDLER_EPILOG;
return ERROR_SUCCESS;
}
BOOL CBFXmlDoc::loadXML(LPCTSTR xmlFile)
{
if (StrCmp(xmlFile, _T("")) == 0)
return FALSE;
m_xmlFile = xmlFile;
// In MSDN, search for "White Space Handling"
// In order to have a "half-preserved" property.
// Need to set it to FALSE before loading the doc.
// Then set it back to TRUE after loading.
if (!setPreserveWhiteSpace(FALSE))
return FALSE;
VARIANT_BOOL vb;
HRESULT hr = m_pDoc->load(CComVariant(m_xmlFile), &vb);
if (FAILED(hr) || vb == VARIANT_FALSE)
return FALSE;
//CComPtr<IXMLDOMParseError> pErrObj;
//m_pDoc->get_parseError(&pErrObj);
//BSTR reason;
//pErrObj->get_reason(&reason);
if (!setPreserveWhiteSpace(TRUE))
return FALSE;
return TRUE;
}
void ValueSetterDialog::resetCombos(long meterIndex)
{
xml = L"";
BSTR xPath = L"";
if (meterIndex >= 0)
{
IMeter *pMeter;
meters->Item(CComVariant(meterIndex), &pMeter);
IMetaData *pMetaData = 0;
pMeter->QueryInterface(_uuidof(IMetaData), (void**)&pMetaData);
if (pMetaData)
{
BSTR xmlString;
if (SUCCEEDED(pMetaData->GetMetaData(&xmlString)))
{
xPath = L"//valueset[@id=//method[@name=\"PutValue\"]/arg[@name=\"selector\"]/valuesetref/@idref]";
xml = xmlString;
}
pMetaData->Release();
}
}
BSTR s;
pController->get_Selector(&s);
_bstr_t _s(s);
selectorList.init(m_hWnd, IDC_COMBO_SELECTOR, xml, xPath, _s);
resetValueCombo(_s);
}
void CPhotoManager::SetElemStyle(CComPtr<IHTMLElement> spElem, long lElemWidth, long lElemHeight)
{
if (spElem == NULL)
return;
HRESULT hr = S_OK;
CComPtr<IHTMLStyle> spStyle;
hr = spElem->get_style(&spStyle);
if (spStyle == NULL)
return;
//j Doesn't work yet hr = spStyle->put_textAlign(CComBSTR("center"));
//j Doesn't work yet hr = spStyle->put_verticalAlign(CComVariant(CComBSTR("center")));
hr = spStyle->put_width(CComVariant(lElemWidth));
hr = spStyle->put_height(CComVariant(lElemHeight));
}
bool CreateXMLNode(CComPtr<IXMLDOMDocument> doc, CComPtr<IXMLDOMNode> node, const TCHAR *nodeName, IXMLDOMNode ** newNode)
{
CComPtr <IXMLDOMNode> sceneNode;
doc->createNode(CComVariant(NODE_ELEMENT), CComBSTR(nodeName), NULL, &sceneNode);
node->appendChild(sceneNode, newNode);
return true;
}
LRESULT DlgSettingsMain::OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
SettingsDlgsMap::iterator it = m_settingsDlgMap.begin();
for (; it != m_settingsDlgMap.end(); ++it)
{
if ((it->second)->SendMessage(WM_COMMAND, wID, 0) != 0)
{
m_treeCtrl.Select(it->first, TVGN_CARET);
return -1;
}
}
for (it = m_settingsDlgMap.begin(); it != m_settingsDlgMap.end(); ++it)
{
it->second->DestroyWindow();
}
if (wID == IDOK)
{
if (m_checkUserDataDir.IsWindowEnabled())
{
g_settingsHandler->SetUserDataDir((m_checkUserDataDir.GetCheck() == 1) ? SettingsHandler::dirTypeUser : SettingsHandler::dirTypeExe);
}
m_pSettingsDocument->save(CComVariant(g_settingsHandler->GetSettingsFileName().c_str()));
}
EndDialog(wID);
return 0;
}
HRESULT DatenBasisObjekt::DelPBDDataIdent (HPROJECT hPr, PBDDATA *pData)
{
TX_ASSERT(IsTRiASDBBased());
// Tabelle liegt in einer Datenquelle
if (HACTPROJECT != hPr) {
ErrCode RC = DB(GetIdentDBHandle (pData -> pbdCode, hPr)).DelPBDDataIdent (pData);
if (EC_OKAY != RC)
return HRESULT_FROM_ERRCODE(RC);
// Notifikation rumschicken
DEXN_FeatureSetModified(pData -> pbdCode);
}
else {
// KurzText muß gegeben sein
TX_ASSERT(pData -> pbdKTextLen > 0 && NULL != pData -> pbdKText);
// übergreifende Objektmenge löschen
WTRiASObjectsCollection ObjsDefs;
RETURN_FAILED_HRESULT(m_Prj -> get_ObjectsDefs (ObjsDefs.ppi()));
RETURN_FAILED_HRESULT(ObjsDefs -> Remove (CComVariant(pData -> pbdKText)));
}
return S_OK;
}
STDMETHODIMP CompositeOverlayImpl<B>::HitTest(/*[in]*/ short X, /*[in]*/ short Y, /*[out, retval]*/ VARIANT_BOOL *retVal)
{
if (retVal == NULL)
return E_POINTER;
*retVal = false;
short count = 0;
Count(&count);
for (int i=count-1; i>=0 && !(*retVal); i--)
{
IOverlay *pItem;
Item(CComVariant(i), &pItem);
VARIANT_BOOL vis;
pItem->get_Visible(&vis);
if (vis)
{
ISimpleOverlay2 *pISO2 = NULL;
HRESULT hr = pItem->QueryInterface(__uuidof(ISimpleOverlay2), (void **)&pISO2);
if (SUCCEEDED(hr))
{
pISO2->HitTest(X, Y, retVal);
pISO2->Release();
}
}
pItem->Release();
}
return S_OK;
}
