int main(int argc, char* argv[])
{
printf(" ***************************************\n");
printf("(c) 2008 Standard MPEG Encoder\n");
printf("Standard Mpeg Encoder & EncodeSample developed by\n");
printf("Mark Essien for Standard MPEG\n");
printf(" ***************************************\n\n");
CoInitialize(0);
// Lets' init graph1 and get it started. The file we are testing with is about 30 seconds long
// so requires about 10 seconds to encode
convert1.SetOutputFormat(SYSTEMSFORMAT_MPEG1, CONSTRAINT_NONE, VIDEOFORMAT_MPEG1, AUDIOFORMAT_MP2);
convert1.SetFiles(CComBSTR("Z:\\Projects\\Standard MPEG\\Test Files\\test_in.mpg"),
CComBSTR("Z:\\Projects\\Standard MPEG\\Test Files\\Output Files\\test_out_1.mpg"));
if (FAILED(convert1.StartConversion()))
{
printf("Conversion failed\n");
}
// the graph will be started in a second thread
// wait for 2 seconds
Sleep(2000);
// Let's start a second graph
convert2.SetOutputFormat(SYSTEMSFORMAT_MPEG1, CONSTRAINT_NONE, VIDEOFORMAT_MPEG1, AUDIOFORMAT_MP2);
convert2.SetFiles(CComBSTR("Z:\\Projects\\Standard MPEG\\Test Files\\test_in.mpg"),
CComBSTR("Z:\\Projects\\Standard MPEG\\Test Files\\Output Files\\test_out_2.mpg"));
if (FAILED(convert2.StartConversion()))
{
printf("Conversion failed\n");
}
// wait 5 seconds
Sleep(5000);
// Let's start a third graph
convert3.SetOutputFormat(SYSTEMSFORMAT_MPEG1, CONSTRAINT_NONE, VIDEOFORMAT_MPEG1, AUDIOFORMAT_MP2);
convert3.SetFiles(CComBSTR("Z:\\Projects\\Standard MPEG\\Test Files\\test_in.mpg"),
CComBSTR("Z:\\Projects\\Standard MPEG\\Test Files\\Output Files\\test_out_3.mpg"));
if (FAILED(convert3.StartConversion()))
{
printf("Conversion failed\n");
}
// Now we wait for graph 1 to end
convert1.WaitForCompletion();
convert1.StopConversion();
// Now we wait for graph 2 to end
convert2.WaitForCompletion();
convert2.StopConversion();
// we restart graph1
convert1.SetOutputFormat(SYSTEMSFORMAT_MPEG1, CONSTRAINT_NONE, VIDEOFORMAT_MPEG1, AUDIOFORMAT_MP2);
convert1.SetFiles(CComBSTR("Z:\\Projects\\Standard MPEG\\Test Files\\test_in.mpg"),
CComBSTR("Z:\\Projects\\Standard MPEG\\Test Files\\Output Files\\test_out_1b.mpg"));
if (FAILED(convert1.StartConversion()))
{
printf("Conversion failed\n");
}
// wait for graph 3 to complete
convert3.WaitForCompletion();
convert3.StopConversion();
// We wait for graph 1b to end
convert1.WaitForCompletion();
convert1.StopConversion();
printf("\n\n\n***************************************\n\n");
printf("Conversion complete. Press any key to exit");
_getch(); // wait for user to press a key
return 0;
}
void CreateToolbars()
{
if (Glb_toolbarArray.GetCount() > 0)
return;
IAcadMenuGroup *mnuGrp = NULL;
if (!getAcadMenuGroup(&mnuGrp))
return ;
IAcadToolbars *tlbrs = NULL;
HRESULT hr = S_OK;
hr = mnuGrp->get_Toolbars(&tlbrs);
mnuGrp->Release();
// 得到arx所在路径
TCHAR lpPath[MAX_PATH] = {0};
GetModuleFileName(GetModuleHandle("DistToolBar.arx"), lpPath, MAX_PATH);
PathRemoveFileSpec(lpPath);
PathAddBackslash(lpPath);
CString strXmlFile = lpPath;
strXmlFile += "toolbar.xml";
// 得到icon路径
PathAppend(lpPath, "icon");
PathAddBackslash(lpPath);
MSXML2::IXMLDOMDocumentPtr lpDocument;
hr = lpDocument.CreateInstance(__uuidof(DOMDocument));
if ( FAILED(hr) )
_com_raise_error(hr);
VARIANT_BOOL isSuccessful;
// 装载XML字符串
if (!lpDocument->load(_variant_t(strXmlFile)))
{
OutputDebugString("LoadXML failed!");
return;
}
MSXML2::IXMLDOMElementPtr lpDocElement = NULL;
lpDocument->get_documentElement(&lpDocElement);
// toolbar list
MSXML2::IXMLDOMNodeListPtr lpToolbarList = lpDocElement->getElementsByTagName(_bstr_t("toolbar"));
MSXML2::IXMLDOMNodePtr lpToolbar = NULL;
for ( ; (lpToolbar = lpToolbarList->nextNode()) != NULL ; )
{
MSXML2::IXMLDOMNodePtr lpCaptionNode = lpToolbar->attributes->getNamedItem("caption");
CString strCaption = (char*)lpCaptionNode->text;
OutputDebugString(strCaption);
// 添加工具条
IAcadToolbar *tlbr = NULL;
hr = tlbrs->Add(CComBSTR(strCaption), &tlbr);
if FAILED(hr)
continue;
Glb_toolbarArray.Add(strCaption);
// button list
MSXML2::IXMLDOMNodeListPtr lpButtonList = lpToolbar->GetchildNodes();
MSXML2::IXMLDOMNodePtr lpButton = NULL;
for ( ; (lpButton = lpButtonList->nextNode()) != NULL ; )
{
MSXML2::IXMLDOMNodePtr lpToolTipNode = lpButton->attributes->getNamedItem("tooltip");
CString strToolTip = (char*)lpToolTipNode->text;
MSXML2::IXMLDOMNodePtr lpCommandNode = lpButton->attributes->getNamedItem("command");
CString strCommand = (char*)lpCommandNode->text;
strCommand += " ";
MSXML2::IXMLDOMNodePtr lpIconNode = lpButton->attributes->getNamedItem("icon");
CString strIcon = (char*)lpIconNode->text;
OutputDebugStringX("tooltip=%s, command=%s, icon=%s", strToolTip, strCommand, strIcon);
// 添加工具按钮
IAcadToolbarItem *button=NULL;
VARIANT index;
index.vt = VT_I4;
index.lVal = 100l;
VARIANT vtFalse;
vtFalse.vt = VT_BOOL;
vtFalse.boolVal = VARIANT_FALSE;
CString strIconFile = lpPath;
strIconFile += strIcon;
if (!PathFileExists(strIconFile))
{
strIconFile = lpPath;
strIconFile += "dist.ico";
}
if (!PathFileExists(strIconFile)) continue;
hr = tlbr->AddToolbarButton(index, CComBSTR(strToolTip), CComBSTR(strToolTip), CComBSTR(strCommand), vtFalse, &button);
hr = button->SetBitmaps(CComBSTR(strIconFile), CComBSTR(strIconFile));
button->Release();
}
tlbr->Dock(acToolbarDockRight);//acToolbarFloating
tlbr->Release();
}
tlbrs->Release();
return;
}
/**
* Saves a rendering of the current site by its host container as a PNG file.
* This implementation is derived from IECapt.
*
* @param outputFile the file to save the PNG output as
* @link http://iecapt.sourceforge.net/
*/
STDMETHODIMP CCoSnapsie::saveSnapshot(
BSTR outputFile,
BSTR frameId,
LONG drawableScrollWidth,
LONG drawableScrollHeight,
LONG drawableClientWidth,
LONG drawableClientHeight,
LONG drawableClientLeft,
LONG drawableClientTop,
LONG frameBCRLeft,
LONG frameBCRTop)
{
HRESULT hr;
HWND hwndBrowser;
CComPtr<IOleClientSite> spClientSite;
CComQIPtr<IServiceProvider> spISP;
CComPtr<IWebBrowser2> spBrowser;
CComPtr<IDispatch> spDispatch;
CComQIPtr<IHTMLDocument2> spDocument;
CComPtr<IHTMLWindow2> spScrollableWindow;
CComQIPtr<IViewObject2> spViewObject;
CComPtr<IHTMLStyle> spStyle;
CComQIPtr<IHTMLElement2> spScrollableElement;
CComVariant documentHeight;
CComVariant documentWidth;
CComVariant viewportHeight;
CComVariant viewportWidth;
GetSite(IID_IUnknown, (void**)&spClientSite);
if (spClientSite == NULL)
{
Error(L"There is no site.");
return E_FAIL;
}
spISP = spClientSite;
if (spISP == NULL)
{
Error(L"Unable to convert client site to service provider.");
return E_FAIL;
}
// from http://support.microsoft.com/kb/257717
hr = spISP->QueryService(IID_IWebBrowserApp, IID_IWebBrowser2, (void **)&spBrowser);
if (FAILED(hr)) {
// if we can't query the client site for IWebBrowser2, we're probably
// in an HTA. Obtain the IHTMLWindow2 interface pointer by directly
// querying the client site's service provider.
// http://groups.google.com/group/microsoft.public.vc.language/browse_thread/thread/f8987a31d47cccfe/884cb8f13423039e
CComPtr<IHTMLWindow2> spWindow;
hr = spISP->QueryService(IID_IHTMLWindow2, &spWindow);
if (FAILED(hr)) {
Error("Failed to obtain IHTMLWindow2 from service provider");
return E_FAIL;
}
hr = spWindow->get_document(&spDocument);
if (FAILED(hr)) {
Error("Failed to obtain IHTMLDocument2 from window");
return E_FAIL;
}
CComQIPtr<IOleWindow> spOleWindow = spDocument;
if (spOleWindow == NULL) {
Error("Failed to obtain IOleWindow from document");
return E_FAIL;
}
hr = spOleWindow->GetWindow(&hwndBrowser);
if (FAILED(hr)) {
Error("Failed to obtain HWND from OLE window");
return E_FAIL;
}
hwndBrowser = GetAncestor(hwndBrowser, GA_ROOTOWNER);
}
else {
hr = spBrowser->get_HWND((long*)&hwndBrowser);
if (FAILED(hr)) {
Error("Failed to get HWND for browser (is this a frame?)");
return E_FAIL;
}
ie = GetAncestor(hwndBrowser, GA_ROOTOWNER);
CComPtr<IDispatch> spDispatch;
hr = spBrowser->get_Document(&spDispatch);
if (FAILED(hr))
return E_FAIL;
spDocument = spDispatch;
if (spDocument == NULL)
return E_FAIL;
IServiceProvider* pServiceProvider = NULL;
if (SUCCEEDED(spBrowser->QueryInterface(
IID_IServiceProvider,
(void**)&pServiceProvider)))
{
IOleWindow* pWindow = NULL;
if (SUCCEEDED(pServiceProvider->QueryService(
SID_SShellBrowser,
IID_IOleWindow,
(void**)&pWindow)))
{
if (SUCCEEDED(pWindow->GetWindow(&hwndBrowser)))
{
hwndBrowser = FindWindowEx(hwndBrowser, NULL, _T("Shell DocObject View"), NULL);
if (hwndBrowser)
{
hwndBrowser = FindWindowEx(hwndBrowser, NULL, _T("Internet Explorer_Server"), NULL);
}
}
pWindow->Release();
}
pServiceProvider->Release();
}
}
// Nobody else seems to know how to get IViewObject2?!
// http://starkravingfinkle.org/blog/2004/09/
spViewObject = spDocument;
if (spViewObject == NULL)
{
Error(L"Unable to convert document to view object.");
return E_FAIL;
}
CComQIPtr<IHTMLDocument5> spDocument5;
spDocument->QueryInterface(IID_IHTMLDocument5, (void**)&spDocument5);
if (spDocument5 == NULL)
{
Error(L"Snapsie requires IE6 or greater.");
return E_FAIL;
}
CComBSTR compatMode;
spDocument5->get_compatMode(&compatMode);
// In non-standards-compliant mode, the BODY element represents the canvas.
if (compatMode == L"BackCompat")
{
CComPtr<IHTMLElement> spBody;
spDocument->get_body(&spBody);
if (NULL == spBody)
{
return E_FAIL;
}
spBody->getAttribute(CComBSTR("scrollHeight"), 0, &documentHeight);
spBody->getAttribute(CComBSTR("scrollWidth"), 0, &documentWidth);
spBody->getAttribute(CComBSTR("clientHeight"), 0, &viewportHeight);
spBody->getAttribute(CComBSTR("clientWidth"), 0, &viewportWidth);
}
// In standards-compliant mode, the HTML element represents the canvas.
else
{
CComQIPtr<IHTMLDocument3> spDocument3;
spDocument->QueryInterface(IID_IHTMLDocument3, (void**)&spDocument3);
if (NULL == spDocument3)
{
Error(L"Unable to get IHTMLDocument3 handle from document.");
return E_FAIL;
}
// The root node should be the HTML element.
CComPtr<IHTMLElement> spRootNode;
spDocument3->get_documentElement(&spRootNode);
if (NULL == spRootNode)
{
Error(L"Could not retrieve root node.");
return E_FAIL;
}
CComPtr<IHTMLHtmlElement> spHtml;
spRootNode->QueryInterface(IID_IHTMLHtmlElement, (void**)&spHtml);
if (NULL == spHtml)
{
Error(L"Root node is not the HTML element.");
return E_FAIL;
}
spRootNode->getAttribute(CComBSTR("scrollHeight"), 0, &documentHeight);
spRootNode->getAttribute(CComBSTR("scrollWidth"), 0, &documentWidth);
spRootNode->getAttribute(CComBSTR("clientHeight"), 0, &viewportHeight);
spRootNode->getAttribute(CComBSTR("clientWidth"), 0, &viewportWidth);
}
// Figure out how large to make the window. It's not sufficient to just use the dimensions of the scrolled
// viewport because the browser chrome occupies space that must be accounted for as well.
RECT ieWindowRect;
GetWindowRect(ie, &ieWindowRect);
int ieWindowWidth = ieWindowRect.right - ieWindowRect.left;
int ieWindowHeight = ieWindowRect.bottom - ieWindowRect.top;
RECT contentClientRect;
GetClientRect(hwndBrowser, &contentClientRect);
int contentClientWidth = contentClientRect.right - contentClientRect.left;
int contentClientHeight = contentClientRect.bottom - contentClientRect.top;
int chromeWidth = ieWindowWidth - contentClientWidth;
int chromeHeight = 2 * (ieWindowHeight - contentClientHeight);
int imageHeight = documentHeight.intVal;
int imageWidth = documentWidth.intVal;
maxWidth = imageWidth + chromeWidth;
maxHeight = imageHeight + chromeHeight;
long originalHeight, originalWidth;
spBrowser->get_Height(&originalHeight);
spBrowser->get_Width(&originalWidth);
// The resize message is being ignored if the window appears to be maximized. There's likely a
// way to bypass that. My ghetto way is to unmaximize the window, then move on with setting
// the window to the dimensions we really want. This is okay because we revert back to the
// original dimensions afterward.
BOOL isMaximized = IsZoomed(ie);
if (isMaximized)
{
ShowWindow(ie, SW_SHOWNORMAL);
}
// Get the path to this DLL so we can load it up with LoadLibrary.
TCHAR dllPath[_MAX_PATH];
GetModuleFileName((HINSTANCE) &__ImageBase, dllPath, _MAX_PATH);
// Get the path to the Windows hook we use to allow resizing the window greater than the virtual screen resolution.
HINSTANCE hinstDLL = LoadLibrary(dllPath);
HOOKPROC hkprcSysMsg = (HOOKPROC)GetProcAddress(hinstDLL, "CallWndProc");
if (hkprcSysMsg == NULL)
PrintError(L"GetProcAddress");
// Install the Windows hook.
nextHook = SetWindowsHookEx(WH_CALLWNDPROC, hkprcSysMsg, hinstDLL, 0);
if (nextHook == 0)
PrintError(L"SetWindowsHookEx");
spBrowser->put_Height(maxHeight);
spBrowser->put_Width(maxWidth);
// Capture the window's canvas to a DIB.
CImage image;
image.Create(imageWidth, imageHeight, 24);
CImageDC imageDC(image);
hr = PrintWindow(hwndBrowser, imageDC, PW_CLIENTONLY);
if (FAILED(hr))
{
Error(L"PrintWindow");
}
// I'm not sure if PrintWindow captures alpha blending or not. OleDraw does, but I was having
// issues with sizing the browser correctly between quirks and standards modes to capture everything we need.
//
//RECT rcBounds = { 0, 0, imageWidth, imageHeight };
//hr = OleDraw(spViewObject, DVASPECT_DOCPRINT, imageDC, &rcBounds);
//if (FAILED(hr))
//{
// Error(L"OleDraw");
//}
UnhookWindowsHookEx(nextHook);
// Restore the browser to the original dimensions.
if (isMaximized)
{
ShowWindow(ie, SW_MAXIMIZE);
}
else
{
spBrowser->put_Height(originalHeight);
spBrowser->put_Width(originalWidth);
}
hr = image.Save(CW2T(outputFile));
if (FAILED(hr))
{
PrintError(L"Failed saving image.");
return E_FAIL;
}
return hr;
}
STDMETHODIMP CTimelineLoadingService::OnFinish(IVariantObject *pResult)
{
CComPtr<IObjArray> pItems;
RETURN_IF_FAILED(m_pTimelineControl->GetItems(&pItems));
UINT uiCount = 0;
RETURN_IF_FAILED(pItems->GetCount(&uiCount));
if (uiCount)
{
CComPtr<IVariantObject> pFirstItem;
RETURN_IF_FAILED(pItems->GetAt(0, __uuidof(IVariantObject), (LPVOID*)&pFirstItem));
CComVar vId;
RETURN_IF_FAILED(pFirstItem->GetVariantValue(ObjectModel::Metadata::Object::Id, &vId));
CComVar vObjectType;
RETURN_IF_FAILED(pFirstItem->GetVariantValue(ObjectModel::Metadata::Object::Type, &vObjectType));
if (vId.vt == VT_I4 && vObjectType.vt == VT_BSTR && vId.intVal == CUSTOM_OBJECT_LOADING_ID && CComBSTR(vObjectType.bstrVal) == Twitter::Metadata::Types::CustomTimelineObject)
{
{
CUpdateScope scope(m_pTimelineControl);
RETURN_IF_FAILED(m_pTimelineControl->RemoveItemByIndex(0));
}
if (uiCount == 1)
{
HWND hWnd = 0;
RETURN_IF_FAILED(m_pTimelineControl->GetHWND(&hWnd));
InvalidateRect(hWnd, nullptr, true);
}
}
}
return S_OK;
}
HRESULT CXMLDocument::SetFYSError()
{
CString strErrorNode = m_strErrorNode;
strErrorNode.MakeUpper();
if (strErrorNode == "FILES")
{
MSXML2::IXMLDOMNodePtr pFilesNode;
CComBSTR strValue;
m_pDoc->selectSingleNode(CComBSTR("//FYS_DATASTREAMACKNOWLEDGMENT/FILES"), &pFilesNode);
CString strStatus = GetStringValue("Status", pFilesNode);
CString strDescription;
strStatus.MakeUpper();
if (strStatus == "INVALIDSTREAMFORMAT")
strDescription = "Invalid Stream Header Xml.";
if (strStatus == "INTERNALERROR")
strDescription = "Unknown Error.";
m_strErrorMessage.Format("Failed to send the card for printing!.\n"
"Uploaded Files Count : %s\n"
"Uploaded Total Size : %s\n"
"Uploaded Files Status : %s\n"
"Error Description : %s\n",
GetStringValue("Count", pFilesNode),
GetStringValue("TotalSize", pFilesNode),
GetStringValue("Status", pFilesNode),
strDescription);
}
if (strErrorNode == "FILE")
{
MSXML2::IXMLDOMNodePtr pFileNode;
m_pDoc->selectSingleNode(CComBSTR("//FYS_DATASTREAMACKNOWLEDGMENT/FILES/FILE[@Status != 'OK']"), &pFileNode);
m_strErrorMessage.Format("Failed to send the card for printing!.\n"
"Uploaded File Name : %s\n"
"Uploaded File Size : %s\n"
"Uploaded File Status : %s\n",
GetStringValue("Name", pFileNode),
GetStringValue("Size", pFileNode),
GetStringValue("Status", pFileNode));
}
if (strErrorNode == "DATAENVELOPE")
{
MSXML2::IXMLDOMNodePtr pDtEnvNode;
m_pDoc->selectSingleNode(CComBSTR("//FYS_DATASTREAMACKNOWLEDGMENT/DATAENVELOPE"), &pDtEnvNode);
m_strErrorMessage.Format("Failed to send the card for printing!.\n"
"Uploaded DataEnvelope Status: %s\n"
"Error Description: %s\n",
GetStringValue("Status", pDtEnvNode),
"DataEnvelope file not received");
}
if (strErrorNode == "XMLPARSEERRORDETAILS")
{
MSXML2::IXMLDOMNodePtr pPrsErrNode;
m_pDoc->selectSingleNode(CComBSTR("//FYS_DATASTREAMACKNOWLEDGMENT/DATAENVELOPE/XMLPARSEERRORDETAILS"), &pPrsErrNode);
m_strErrorMessage.Format("Failed to send the card for printing!.\n"
"Uploaded DataEnvelope file was malformed\n"
"Error Description : %s\n"
"Error Text : %s\n"
"Error Location : %s\n",
GetStringValue("ErrorDescription", pPrsErrNode),
GetStringValue("ErrorText", pPrsErrNode),
GetStringValue("Location", pPrsErrNode));
}
return S_OK;
}
HRESULT AbstractDeviceContent::GetValue(
REFPROPERTYKEY Key,
_Out_ IPortableDeviceValues* pStore)
{
HRESULT hr = S_OK;
PropVariantWrapper pvValue;
if(pStore == NULL)
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL parameter");
return hr;
}
if (IsEqualPropertyKey(Key, WPD_OBJECT_ID))
{
// Add WPD_OBJECT_ID
pvValue = ObjectID;
hr = pStore->SetValue(WPD_OBJECT_ID, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_ID"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_PERSISTENT_UNIQUE_ID))
{
// Add WPD_OBJECT_PERSISTENT_UNIQUE_ID
pvValue = this->PersistentUniqueID;
hr = pStore->SetValue(WPD_OBJECT_PERSISTENT_UNIQUE_ID, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_PERSISTENT_UNIQUE_ID"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_PARENT_ID))
{
// Add WPD_OBJECT_PARENT_ID
pvValue = ParentID;
hr = pStore->SetValue(WPD_OBJECT_PARENT_ID, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_PARENT_ID"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_NAME))
{
// Add WPD_OBJECT_NAME
pvValue = Name;
hr = pStore->SetValue(WPD_OBJECT_NAME, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_NAME"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_CONTENT_TYPE))
{
// Add WPD_OBJECT_CONTENT_TYPE
hr = pStore->SetGuidValue(WPD_OBJECT_CONTENT_TYPE, ContentType);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_CONTENT_TYPE"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_FORMAT))
{
// Add WPD_OBJECT_FORMAT
hr = pStore->SetGuidValue(WPD_OBJECT_FORMAT, Format);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_FORMAT"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_CAN_DELETE))
{
// Add WPD_OBJECT_CAN_DELETE
hr = pStore->SetBoolValue(WPD_OBJECT_CAN_DELETE, CanDelete);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_CAN_DELETE"));
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
CHECK_HR(hr, "Property {%ws}.%d is not supported", CComBSTR(Key.fmtid), Key.pid);
}
return hr;
}
void CStrokeRecognition::DecodePointFromXML(std::vector<POINT> &rgPoints, BSTR strXML)
{
IXMLDOMDocument* pDoc;
IXMLDOMNodeList* pNodeList;
IXMLDOMNode* pNode;
IXMLDOMNode* pInputNode;
IXMLDOMNode* pAttrNode;
IXMLDOMNamedNodeMap* pNodeMap;
VARIANT_BOOL bLoaded;
VARIANT value;
BSTR nodeName;
POINT pt;
long n;
if (SUCCEEDED(CoCreateInstance(CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument, (LPVOID*)&pDoc)))
{
pDoc->put_async(VARIANT_FALSE);
pDoc->loadXML(strXML, &bLoaded);
if (bLoaded == VARIANT_TRUE)
{
if (SUCCEEDED(pDoc->get_childNodes(&pNodeList)))
{
pInputNode = NULL;
pNodeList->get_length(&n);
for (int i = 0; i < n; i++)
{
if (SUCCEEDED(pNodeList->get_item(i, &pNode)))
{
nodeName = NULL;
if (SUCCEEDED(pNode->get_nodeName(&nodeName)))
{
if (CComBSTR(nodeName) == L"input")
{
pInputNode = pNode;
pInputNode->AddRef();
break;
}
SysFreeString(nodeName);
}
pNode->Release();
}
}
pNodeList->Release();
if (pInputNode != NULL)
{
if (SUCCEEDED(pInputNode->get_childNodes(&pNodeList)))
{
pNodeList->get_length(&n);
for (int i = 0; i < n; i++)
{
if (SUCCEEDED(pNodeList->get_item(i, &pNode)))
{
pt.x = 0;
pt.y = 0;
if (SUCCEEDED(pNode->get_attributes(&pNodeMap)))
{
if (SUCCEEDED(pNodeMap->getNamedItem(L"x", &pAttrNode)))
{
pAttrNode->get_nodeValue(&value);
pt.x = _wtoi(value.bstrVal);
pAttrNode->Release();
}
if (SUCCEEDED(pNodeMap->getNamedItem(L"y", &pAttrNode)))
{
pAttrNode->get_nodeValue(&value);
pt.y = _wtoi(value.bstrVal);
pAttrNode->Release();
}
pNodeMap->Release();
}
rgPoints.push_back(pt);
pNode->Release();
}
}
pNodeList->Release();
}
pInputNode->Release();
}
}
}
pDoc->Release();
}
}
/////////////////////////////////////////////////////////////////////////////
// CIbnCommandWnd message handlers
BOOL CIbnCommandWnd::OnCopyData(CWnd *pWnd, COPYDATASTRUCT *pCopyDataStruct)
{
CComBSTR bstrCommandXML = (LPCWSTR)pCopyDataStruct->lpData;
CComBSTR bstrCommandResponse;
if(bstrCommandXML==L"clientInfo")
{
bstrCommandResponse = BuildClientInfoXml();
}
else if(bstrCommandXML==L"contactList")
{
bstrCommandResponse = BuildContactListXml();
}
else
{
CComPtr<IXMLDOMDocument> xmlCommandDoc = NULL;
xmlCommandDoc.CoCreateInstance(CLSID_DOMDocument40, NULL, CLSCTX_INPROC_SERVER);
VARIANT_BOOL varSuc = VARIANT_FALSE;
xmlCommandDoc->loadXML(bstrCommandXML,&varSuc);
if(varSuc==VARIANT_TRUE)
{
CComPtr<IXMLDOMNode> pRootNode;
xmlCommandDoc->selectSingleNode(CComBSTR(L"clientInfo"),&pRootNode);
if(pRootNode!=NULL)
{
bstrCommandResponse = BuildClientInfoXml();
}
else
{
xmlCommandDoc->selectSingleNode(CComBSTR(L"contactList"),&pRootNode);
if(pRootNode!=NULL)
{
bstrCommandResponse = BuildContactListXml();
}
else
{
xmlCommandDoc->selectSingleNode(CComBSTR(L"sendFile"),&pRootNode);
if(pRootNode!=NULL)
{
SendFile(pRootNode);
}
// TODO: Not Supported Command
}
}
}
}
if(bstrCommandResponse.Length()>0)
{
// Send WM_COPYDATA
COPYDATASTRUCT copyDs = {0};
copyDs.cbData = (bstrCommandResponse.Length()+1)*2; // Specifies the size, in bytes, of the data pointed to by the lpData member.
copyDs.lpData = (PVOID)(BSTR)bstrCommandResponse; // Pointer to data to be passed to the receiving application. This member can be NULL.
LRESULT bResult = pWnd->SendMessage(WM_COPYDATA,
(WPARAM)GetSafeHwnd(),
(LPARAM)©Ds);
}
return TRUE;
}
LRESULT CMainDlg::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
DlgResize_Init();
// center the dialog on the screen
CenterWindow();
sAppTooltip="MtConnectDboard";
nIcon=0;
// set icons
HICON hIcon = (HICON)::LoadImage(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDR_MAINFRAME),
IMAGE_ICON, ::GetSystemMetrics(SM_CXICON), ::GetSystemMetrics(SM_CYICON), LR_DEFAULTCOLOR);
SetIcon(hIcon, TRUE);
HICON hIconSmall = (HICON)::LoadImage(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDR_MAINFRAME),
IMAGE_ICON, ::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR);
SetIcon(hIconSmall, FALSE);
// register object for message filtering and idle updates
//CMessageLoop* pLoop = _Module.GetMessageLoop();
CMessageLoop* pLoop = _thread->GetMessageLoop();
ATLASSERT(pLoop != NULL);
pLoop->AddMessageFilter(this);
pLoop->AddIdleHandler(this);
UIAddChildWindowContainer(m_hWnd);
// Remove Max/Min buttons - if using TrayIcon
DWORD style = ::GetWindowLong(this->m_hWnd, GWL_STYLE);
style &= ~(WS_MAXIMIZEBOX); // WS_MINIMIZEBOX NOT WS_THICKFRAME
::SetWindowLong(this->m_hWnd, GWL_STYLE, style);
// Install tray icon
hSmileyIcon = LoadIcon(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDR_MAINFRAME));
hIdleIcon = LoadIcon(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDI_IDLEICON));
hStopIcon = LoadIcon(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDI_STOPICON));
hClearIcon = LoadIcon(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDI_CLEARICON));
InstallIcon(sAppTooltip, hSmileyIcon, IDR_MENU1);
CAxWindow wndIE = GetDlgItem(IDC_EXPLORER1);
HRESULT hr;
hr = wndIE.QueryControl ( &m_spWebBrowser );
if ( m_spWebBrowser )
{
CComVariant v; // empty variant
m_spWebBrowser->Navigate ( CComBSTR("about:blank"),
&v, &v, &v, &v );
}
//Handle NavigateComplete2 event from the browser, get the document element, call DispEventAdvise(pDocument). onclick event bubbles, so you can handle it on the document and get clicks from all contained elements.
//DispEventAdvise(m_spWebBrowser);
//Then you need to register your interface to be used proccess wide:
hr = pGIT->RegisterInterfaceInGlobal( (IUnknown*)(IWebBrowser2*)m_spWebBrowser, IID_IWebBrowser2, &dwWebBrowserCookie);
//std::string html = MTConnectStreamsParser().CreateHtmlDocument();
//CHtmlTableSnapshots().SetDocumentText(m_spWebBrowser,html);
// Icon mapping
std::vector<HICON> icons(2);
icons[0]=hSmileyIcon; icons[1]=hClearIcon; StateIconMap["EXECUTING"] = icons; // flashing green
icons[0]=hSmileyIcon; icons[1]=hSmileyIcon; StateIconMap["IDLE"] = icons; // idle auto
icons[0]=hStopIcon; icons[1]=hStopIcon; StateIconMap["STOPPED"] = icons; // stopped
icons[0]=hStopIcon; icons[1]=hClearIcon; StateIconMap["FAULT"] = icons; // stopped fault
this->SetTimer(1, 250);
dlgMainThead = ::GetCurrentThread();
return TRUE;
}
CComBSTR CIbnCommandWnd::BuildContactListXml()
{
USES_CONVERSION;
CUserCollection UsersContactList;
pMessenger->GetCopyContactList(UsersContactList);
CComPtr<IXMLDOMDocument> pTreeItemDoc = NULL;
pTreeItemDoc.CoCreateInstance(CLSID_DOMDocument40, NULL, CLSCTX_INPROC_SERVER);
VARIANT_BOOL varSuc = VARIANT_FALSE;
CComBSTR bsDefaultXML = L"<contactList><response></response></contactList>";
pTreeItemDoc->loadXML(bsDefaultXML,&varSuc);
CComPtr<IXMLDOMNode> pRootNode;
pTreeItemDoc->selectSingleNode(CComBSTR(L"contactList/response"),&pRootNode);
int CLMode = GetOptionInt(IDS_OFSMESSENGER,IDS_CLMODE,2);
CUser* pUser=NULL;
int GroupGlobalId = -1;
if(POSITION pos = UsersContactList.InitIteration())
{
for(int i=0; UsersContactList.GetNext(pos, pUser); i++)
{
// Step 1. Проверить создавали ли мы группу???
CComBSTR GroupName = pUser->m_strType;
if(CLMode==2)
{
if(pUser->m_iStatus==S_OFFLINE||pUser->m_iStatus==S_INVISIBLE)
{
GroupName = GetString(IDS_OFFLINE);
}
}
BOOL isCheck = FALSE;
CComBSTR bsGroupPath = L"contactList/response/group[@name='";
bsGroupPath += GroupName;
bsGroupPath += L"']";
CComPtr<IXMLDOMNode> pGroupNode;
pTreeItemDoc->selectSingleNode(bsGroupPath,&pGroupNode);
if(pGroupNode==NULL)
{
CComPtr<IXMLDOMNode> pTmpGroupNode;
pTreeItemDoc->createNode(CComVariant(NODE_ELEMENT),CComBSTR(L"group"),NULL,&pTmpGroupNode);
SetAttribute(pTmpGroupNode,CComBSTR(L"name"),CComVariant(GroupName));
pGroupNode = AppendWithSort(pRootNode, pTmpGroupNode, CComBSTR(L"text"));
}
// Step 3. добавить пользователя [1/28/2002]
CComPtr<IXMLDOMNode> pUserNode;
insertSingleNode(pGroupNode, CComBSTR(L"user"), NULL, NULL, &pUserNode);
WCHAR buffUserId[20] = L"";
_ltow(pUser->GetGlobalID(),buffUserId,10);
WCHAR buffUserStatus[20] = L"";
_ltow(pUser-> GetStatus(),buffUserStatus,10);
insertSingleNode(pUserNode, CComBSTR(L"id"), NULL, CComBSTR(buffUserId));
insertSingleNode(pUserNode, CComBSTR(L"login"), NULL, CComBSTR((LPCTSTR)pUser->m_strLogin));
insertSingleNode(pUserNode, CComBSTR(L"firstName"), NULL, CComBSTR((LPCTSTR)pUser->m_strFirstName));
insertSingleNode(pUserNode, CComBSTR(L"lastName"), NULL, CComBSTR((LPCTSTR)pUser->m_strLastName));
insertSingleNode(pUserNode, CComBSTR(L"email"), NULL, CComBSTR((LPCTSTR)pUser->m_strEMail));
insertSingleNode(pUserNode, CComBSTR(L"status"), NULL, CComBSTR(buffUserStatus));
}
}
CComBSTR bsRetVal;
pTreeItemDoc->get_xml(&bsRetVal);
return bsRetVal;
}
BOOL CIbnCommandWnd::SendScreenCaptureCommand(CComBSTR Command, CComBSTR Mode, CComBSTR RecipientsXml)
{
// Create Hwnd String
WCHAR wsTmpBuf[20];
_ltow((long)pMessenger->GetSafeHwnd(),wsTmpBuf,10);
CComBSTR bstrClientHwnd = wsTmpBuf;
// Create Xml Command
CComBSTR sendXML;
sendXML += CComBSTR(L"<");
sendXML += Command;
sendXML += CComBSTR(L">");
sendXML += CComBSTR(L"<request>");
sendXML += CComBSTR(L"<ibnClientHandle>");
sendXML += bstrClientHwnd;
sendXML += CComBSTR(L"</ibnClientHandle>");
sendXML += CComBSTR(L"<mode>");
sendXML += Mode;
sendXML += L"</mode>";
if(RecipientsXml.Length()>0)
{
sendXML += CComBSTR(L"<recipients>");
sendXML += RecipientsXml;
sendXML += L"</recipients>";
}
sendXML += CComBSTR(L"</request>");
sendXML += CComBSTR(L"</");
sendXML += Command;
sendXML += CComBSTR(L">");
// Test Only
//sendXML = L"<clientInfo></clientInfo>";
// TODO: Find Screen Capture Window
LPCTSTR szScreenCaptureClassName = _T("#32770");
LPCTSTR szScreenCaptureWindowName = _T("{19791104-A59E-42e5-BB49-200706080000}");
CWnd *pScreenCaptureCommandWnd = FindWindow(szScreenCaptureClassName,szScreenCaptureWindowName);
if(pScreenCaptureCommandWnd==NULL)
{
// TODO:
CString screenCapurePath = pMessenger->ScreenCapturePath();
// Run Screen Capture
if(screenCapurePath.GetLength()>0)
{
HINSTANCE retVal = ShellExecute(::GetDesktopWindow(),NULL,screenCapurePath,_T(""),NULL,SW_SHOWNORMAL);
if((int)retVal>32)
{
// Find Screen Capture Window Again
for(int index=0; index<20; index++)
{
Sleep(500);
pScreenCaptureCommandWnd = FindWindow(szScreenCaptureClassName,szScreenCaptureWindowName);
if(pScreenCaptureCommandWnd!=NULL)
break;
}
}
}
}
if(pScreenCaptureCommandWnd!=NULL)
{
// Send WM_COPYDATA
COPYDATASTRUCT copyDs = {0};
copyDs.cbData = (sendXML.Length()+1)*2; // Specifies the size, in bytes, of the data pointed to by the lpData member.
copyDs.lpData = (PVOID)(BSTR)sendXML; // Pointer to data to be passed to the receiving application. This member can be NULL.
LRESULT bResult = pScreenCaptureCommandWnd->SendMessage(WM_COPYDATA,
(WPARAM)GetSafeHwnd(),
(LPARAM)©Ds);
return TRUE;
}
return FALSE;
}
HRESULT SoundDA::SetDaqHwInfo()
{
CComPtr<IProp> prop;
// hwinfo property container
CComQIPtr<IPropContainer> pCont(GetHwInfo());
// total channels
CComVariant var,vids;
short ids[]={1,2};
if (WaveCaps.IsStereo())
{
var=2L;
CreateSafeVector(ids,2,&vids);
}
else
{
var=1L;
CreateSafeVector(ids,1,&vids);
}
HRESULT hRes = pCont->put_MemberValue(L"totalchannels",var);
if (!(SUCCEEDED(hRes))) return hRes;
hRes = pCont->put_MemberValue(L"channelids", vids);
if (!(SUCCEEDED(hRes))) return hRes;
wchar_t idStr[8];
swprintf(idStr, L"%d", _id);
hRes = pCont->put_MemberValue(L"id", CComVariant(idStr));
if (!(SUCCEEDED(hRes))) return hRes;
hRes = pCont->put_MemberValue(L"polarity", CComVariant(L"Bipolar"));
if (!(SUCCEEDED(hRes))) return hRes;
hRes = pCont->put_MemberValue(L"coupling", CComVariant(L"AC Coupled"));
if (!(SUCCEEDED(hRes))) return hRes;
// subsystem type
hRes = pCont->put_MemberValue(L"subsystemtype",CComVariant(L"AnalogOutput"));
if (!(SUCCEEDED(hRes))) return hRes;
// autocal
//hRes = pCont->put_MemberValue(CComBSTR(L"autocalibrate"),CComVariant(0L));
//if (!(SUCCEEDED(hRes))) return hRes;
hRes = pCont->put_MemberValue(L"sampletype",CComVariant(1L));
if (!(SUCCEEDED(hRes))) return hRes;
// number of bits
CComVariant val;
val = WaveCaps.Supports16Bit() ? 16L : 8L;
hRes = pCont->put_MemberValue(CComBSTR(L"bits"),val);
if (!(SUCCEEDED(hRes))) return hRes;
hRes = pCont->put_MemberValue(L"adaptorname",
CComVariant(L"winsound"));
if (!(SUCCEEDED(hRes))) return hRes;
// driver description
bstr_t name = WaveCaps.GetDeviceName();
V_VT(&val) = VT_BSTR;
V_BSTR(&val) = name;
hRes = pCont->put_MemberValue(L"devicename",val);
if (!(SUCCEEDED(hRes))) return hRes;
hRes = pCont->put_MemberValue(L"vendordriverdescription",
CComVariant(L"Windows Multimedia Driver"));
if (!(SUCCEEDED(hRes))) return hRes;
hRes = pCont->put_MemberValue(L"vendordriverversion",CComVariant(WaveCaps.GetDriverVersion()));
if (!(SUCCEEDED(hRes))) return hRes;
// native data type
var = WaveCaps.Supports16Bit() ? VT_I2 : VT_UI1;
hRes = pCont->put_MemberValue(L"nativedatatype", var);
if (!(SUCCEEDED(hRes))) return hRes;
SetSampleRateRange(8000,static_cast<long>(WaveCaps.GetMaxSampleRate()));
// input ranges --> move to input group
SAFEARRAY *ps = SafeArrayCreateVector(VT_R8, 0, 2);
if (ps==NULL)
return E_OUTOFMEMORY;
val.parray=ps;
val.vt = VT_ARRAY | VT_R8;
double *pr;
hRes = SafeArrayAccessData(ps, (void **) &pr);
if (FAILED (hRes))
{
SafeArrayDestroy (ps);
return hRes;
}
pr[0]=-1;
pr[1]=1;
SafeArrayUnaccessData (ps);
hRes = pCont->put_MemberValue(CComBSTR(L"outputranges"), val);
if (!(SUCCEEDED(hRes))) return hRes;
return S_OK;
}
LRESULT CTangramWordPlusDocWnd::OOpenDoc(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& )
{
map<LONG, Office::_CustomTaskPane*>::iterator it = m_pWordAddin->m_mapTaskPaneMap.find((LONG)m_hWnd);
if (it != m_pWordAddin->m_mapTaskPaneMap.end())
{
it->second->put_Visible(false);
m_pWordAddin->m_mapTaskPaneMap.erase(it);
}
if(m_pWordAddin->m_pCurWordPlusDocWnd==NULL)
return 0;
CTangramWordPlusDocWnd* pWnd = m_pWordAddin->m_pCurWordPlusDocWnd;
pWnd->m_pWordPlusDoc = (CTangramWordPlusDoc*)wParam;
if(lParam==1&& pWnd)
{
CComBSTR bstrXml(L"");
m_pWordAddin->GetTangramXml(pWnd->m_pWordPlusDoc->m_pDoc,CComBSTR(L"Tangrams"),&bstrXml);
CString strTemplateXml = OLE2T(bstrXml);
pWnd->m_pWordPlusDoc->m_strDocXml = strTemplateXml;
if (strTemplateXml != _T(""))
{
CTangramXmlParse m_Parse;
if (m_Parse.LoadXml(strTemplateXml) || m_Parse.LoadFile(strTemplateXml))
{
CTangramXmlParse* pParse = m_Parse.GetChild(_T("TaskPaneUI"));
if (pParse)
pWnd->m_pWordPlusDoc->m_strTaskPaneXml = pParse->xml();
pParse = m_Parse.GetChild(_T("DocumentUI"));
if (pParse)
{
CTangramWordPlusDoc* pWordDocument = pWnd->m_pWordPlusDoc;
theApp.m_pTangramCore->CreateTangram((LONGLONG)pWnd->m_hWnd, &pWordDocument->m_pTangram);
if (pWordDocument->m_pTangram)
{
pWordDocument->m_pTangram->put_External(pWordDocument->m_pDoc);
pWordDocument->m_pTangram->CreateFrame(CComVariant(0), CComVariant((LONGLONG)m_pWordAddin->m_pCurWordPlusDocWnd->m_hDocWnd), CComBSTR(L"Document"), &pWordDocument->m_pFrame);
if (pWordDocument->m_pFrame)
{
CString strXml = pParse->xml();
CComPtr<ITangramNode> pNode;
pWordDocument->m_pFrame->Extend(CComBSTR(L"Default"), strXml.AllocSysString(), &pNode);
}
}
}
pParse = m_Parse.GetChild(_T("UserForms"));
if (pParse)
{
int nCount = pParse->GetCount();
if (nCount)
{
for (int i = 0; i < nCount; i++)
{
CTangramXmlParse* pParse2 = pParse->GetChild(i);
m_pWordPlusDoc->m_mapUserFormScript[pParse2->name()] = pParse2->xml();
}
}
}
}
}
}
return 0;
}
HRESULT WpdCapabilities::DispatchWpdMessage(_In_ REFPROPERTYKEY Command,
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
if (Command.fmtid != WPD_CATEGORY_CAPABILITIES)
{
hr = E_INVALIDARG;
CHECK_HR(hr, "This object does not support this command category %ws",CComBSTR(Command.fmtid));
}
if (hr == S_OK)
{
if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_COMMANDS))
{
hr = OnGetSupportedCommands(pParams, pResults);
CHECK_HR(hr, "Failed to get supported commands");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_COMMAND_OPTIONS))
{
hr = OnGetCommandOptions(pParams, pResults);
CHECK_HR(hr, "Failed to get command options");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_FUNCTIONAL_CATEGORIES))
{
hr = OnGetFunctionalCategories(pParams, pResults);
CHECK_HR(hr, "Failed to get functional categories");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_FUNCTIONAL_OBJECTS))
{
hr = OnGetFunctionalObjects(pParams, pResults);
CHECK_HR(hr, "Failed to get functional objects");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_CONTENT_TYPES))
{
hr = OnGetSupportedContentTypes(pParams, pResults);
CHECK_HR(hr, "Failed to get supported content types");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_FORMATS))
{
hr = OnGetSupportedFormats(pParams, pResults);
CHECK_HR(hr, "Failed to get supported formats");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_FORMAT_PROPERTIES))
{
hr = OnGetSupportedFormatProperties(pParams, pResults);
CHECK_HR(hr, "Failed to get supported format properties");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_FIXED_PROPERTY_ATTRIBUTES))
{
hr = OnGetFixedPropertyAttributes(pParams, pResults);
CHECK_HR(hr, "Failed to get fixed property attributes");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_EVENTS))
{
hr = OnGetSupportedEvents(pParams, pResults);
CHECK_HR(hr, "Failed to get supported events");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_EVENT_OPTIONS))
{
hr = OnGetEventOptions(pParams, pResults);
CHECK_HR(hr, "Failed to get event options");
}
else
{
hr = E_NOTIMPL;
CHECK_HR(hr, "This object does not support this command id %d", Command.pid);
}
}
return hr;
}
/////////////////////////////////////////////////////////////////////////////
// AdaptorInfo()
//
// The function is used to elicit relevant info about the current HW..
//..configuration from the HW API.
// The info to extract is:
//..1)number of boards installed
//..2)board names
//..3)supported subsystems (AnalogInput, AnalogOutput, DigitalIO)
// The function is called by the engine in response to the ML user..
//..command DAQHWINFO
/////////////////////////////////////////////////////////////////////////////
HRESULT Cadvantechadapt::AdaptorInfo(IPropContainer * Container)
{
LONG lDriverHandle = (LONG)NULL; // driver handle
PT_DeviceGetFeatures ptDevFeatures; // Devfeatures table
DEVFEATURES DevFeatures; // structure for device features
int i = 0; // Index variable
// Get the name of the adaptor module
TCHAR name[256];
GetModuleFileName(_Module.GetModuleInstance(),name,256); // null returns MATLAB version (non existant)
RETURN_HRESULT(Container->put_MemberValue(L"adaptordllname",CComVariant(name)));
// Place the adaptor name in the appropriate struct in the engine.
RETURN_HRESULT(Container->put_MemberValue(L"adaptorname",variant_t(ConstructorName)));
// Find board IDs
// Start by obtaining the DeviceList. Not stored.
short numDevices; // Number of devices
DEVLIST deviceList[MaxDev]; // Space to store device information.
CComVariant var; // General CComVariant to return info to adaptor engine.
RETURN_ADVANTECH(DRV_DeviceGetList((DEVLIST far *)&deviceList[0], MaxDev, &numDevices));
// Create storage for board IDs, bord names and constructors.
TSafeArrayVector<CComBSTR> IDs; // Create A SafeArrayVector to store the IDs in
IDs.Allocate(numDevices); // Allocate the memory for the number of devices
TSafeArrayVector<CComBSTR> Names; // Create A SafeArrayVector to store the Names in
Names.Allocate(numDevices); // Allocate the memory for the number of devices
SAFEARRAY *ps; // SafeArray for the subsystem support [nDx3 CComBStrs]
CComBSTR *subsystems;
SAFEARRAYBOUND arrayBounds[2];
arrayBounds[0].lLbound = 0;
arrayBounds[0].cElements = numDevices;
arrayBounds[1].lLbound = 0;
arrayBounds[1].cElements = 3; // AnalogInput, AnalogOutput, DigitalIO subsystems.
ps = SafeArrayCreate(VT_BSTR, 2, arrayBounds);
if (ps==NULL)
return E_FAIL;
// Set up the variant to contain subsystem constructor SafeArray
var.parray = ps;
var.vt = VT_ARRAY | VT_BSTR;
HRESULT hRes = SafeArrayAccessData(ps, (void **)&subsystems);
if (FAILED (hRes))
{
SafeArrayDestroy (ps);
return hRes;
}
// Now loop through each device, getting the ID, BoardName and subsystem support.
wchar_t str[40];
for (i=0; i < numDevices; i++)
{
// Allocate the ID
char* string;
string = new char[20];
_ltoa(deviceList[i].dwDeviceNum, string, 10);
IDs[i] = CComBSTR(string);
// Open Device
RETURN_ADVANTECH(DRV_DeviceOpen(deviceList[i].dwDeviceNum,(LONG far *)&lDriverHandle));
// Get BoardNames info
Names[i] = CComBSTR(deviceList[i].szDeviceName);
// Check to see which subsystems the current board supports.
// Get device features
ptDevFeatures.buffer = (LPDEVFEATURES)&DevFeatures;
ptDevFeatures.size = sizeof(DEVFEATURES);
RETURN_ADVANTECH(DRV_DeviceGetFeatures(lDriverHandle, (LPT_DeviceGetFeatures)&ptDevFeatures));
if ((DevFeatures.usMaxAIDiffChl + DevFeatures.usMaxAISiglChl) > 0)
{
swprintf(str, L"analoginput('%s',%s)", (wchar_t*)ConstructorName, (wchar_t*)IDs[i]);
subsystems[i]=str;
}
if (DevFeatures.usMaxAOChl > 0)
{
swprintf(str, L"analogoutput('%s',%s)", (wchar_t*)ConstructorName, (wchar_t*)IDs[i]);
subsystems[i + numDevices]=str;
}
if ((DevFeatures.usMaxDIChl + DevFeatures.usMaxDOChl) > 0)
{
swprintf(str, L"digitalio('%s',%s)",(wchar_t*) ConstructorName, (wchar_t*)IDs[i]);
subsystems[i + 2*numDevices] = str;
}
// Close device
RETURN_ADVANTECH(DRV_DeviceClose((LONG far *)&lDriverHandle));
}
// Return Object Constructor Names since they're in var already.
SafeArrayUnaccessData (ps);
RETURN_HRESULT(Container->put_MemberValue(L"objectconstructorname",var));
// Return the board names
var.Clear(); // resuse the same 'var' variable for the boardnames.
Names.Detach(&var);
RETURN_HRESULT(Container->put_MemberValue(L"boardnames",var));
// Return the board numbers
var.Clear(); //reuse the same 'var' variable for the IDs[]
IDs.Detach(&var);
RETURN_HRESULT(Container->put_MemberValue(L"installedboardids",var));
return S_OK;
} // end of AdaptorInfo()
HRESULT WpdObjectManagement::DispatchWpdMessage(
const PROPERTYKEY& Command,
IPortableDeviceValues* pParams,
IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
if (hr == S_OK)
{
if (Command.fmtid != WPD_CATEGORY_OBJECT_MANAGEMENT)
{
hr = E_INVALIDARG;
CHECK_HR(hr, "This object does not support this command category %ws",CComBSTR(Command.fmtid));
}
}
if (hr == S_OK)
{
if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_DELETE_OBJECTS.pid)
{
hr = OnDelete(pParams, pResults);
CHECK_HR(hr, "Failed to delete object");
}
else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_CREATE_OBJECT_WITH_PROPERTIES_ONLY.pid)
{
hr = OnCreateObjectWithPropertiesOnly(pParams, pResults);
CHECK_HR(hr, "Failed to create object");
}
else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_CREATE_OBJECT_WITH_PROPERTIES_AND_DATA.pid)
{
hr = OnCreateObjectWithPropertiesAndData(pParams, pResults);
CHECK_HR(hr, "Failed to create object");
}
else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_WRITE_OBJECT_DATA.pid)
{
hr = OnWriteObjectData(pParams, pResults);
CHECK_HR(hr, "Failed to write object data");
}
else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_COMMIT_OBJECT.pid)
{
hr = OnCommit(pParams, pResults);
CHECK_HR(hr, "Failed to commit object");
}
else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_REVERT_OBJECT.pid)
{
hr = OnRevert(pParams, pResults);
CHECK_HR(hr, "Failed to revert object");
}
else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_MOVE_OBJECTS.pid)
{
hr = OnMove(pParams, pResults);
CHECK_HR(hr, "Failed to Move objects");
}
else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_COPY_OBJECTS.pid)
{
hr = OnCopy(pParams, pResults);
CHECK_HR(hr, "Failed to Copy objects");
}
else if (Command.pid == WPD_COMMAND_OBJECT_MANAGEMENT_UPDATE_OBJECT_WITH_PROPERTIES_AND_DATA.pid)
{
hr = OnUpdateObjectWithPropertiesAndData(pParams, pResults);
CHECK_HR(hr, "Failed to update object");
}
else
{
hr = E_NOTIMPL;
CHECK_HR(hr, "This object does not support this command id %d", Command.pid);
}
}
return hr;
}
/*******************************************************************************
Function Name : vInitGraphControl
Input(s) : -
Output : -
Functionality : This function will initialise graph control. This will set
viewstyle parameters of the graph control
Member of : CGraphBottomView
Author(s) : Raja N
Date Created : 10/12/2004
Modifications :
*******************************************************************************/
void CGraphBottomView::vInitGraphControl()
{
CGraphList* podList = NULL;
CGraphChildFrame* pParentWnd = NULL;
pParentWnd = (CGraphChildFrame*)pomGetParentWindow();
if(pParentWnd != NULL)
{
podList = pParentWnd->pGetSignalListDetails();
}
else
{
return;
}
if( podList != NULL )
{
CGraphParameters* pEnv = &podList->m_odGraphParameters;
if( pEnv != NULL )
{
// Init Active Axis
m_nAxis = pEnv->m_nActiveAxis;
// Init Active Action
m_nAction = pEnv->m_nAction;
// Set Show Grid Action
vSetShowButtonState( pEnv->m_bShowGrid );
// Set Graph Params
if( m_pDMGraphCtrl != NULL )
{
// Set Axis Color
m_pDMGraphCtrl->put_AxisColor((OLE_COLOR)pEnv->m_nAxisColor);
// Set Plot Area Color
m_pDMGraphCtrl->put_PlotAreaColor((OLE_COLOR)pEnv->m_nPlotAreaColor);
// Set Grid Color
m_pDMGraphCtrl->put_GridColor((OLE_COLOR)pEnv->m_nGridColor);
// Set Frame Style
m_pDMGraphCtrl->put_FrameStyle((FrameStyle)pEnv->m_nFrameStyle);
// Set Frame Color
m_pDMGraphCtrl->put_ControlFrameColor((OLE_COLOR)pEnv->m_nFrameColor);
// Set Grid Lines Count
CComPtr<IDMGraphAxis> spAxisX;
m_pDMGraphCtrl->get_Axis( HorizontalX, &spAxisX);
spAxisX->put_GridNumber((short)pEnv->m_nXGridLines);
CComPtr<IDMGraphAxis> spAxisY;
m_pDMGraphCtrl->get_Axis( VerticalY, &spAxisY);
spAxisY->put_GridNumber((short)pEnv->m_nYGridLines);
// Set Show Grid
spAxisX->put_ShowGrid(pEnv->m_bShowGrid ? VARIANT_TRUE : VARIANT_FALSE);
spAxisY->put_ShowGrid(pEnv->m_bShowGrid ? VARIANT_TRUE : VARIANT_FALSE);
// Set Format String
spAxisX->put_Format( CComBSTR(defSTR_X_AXIS_FORMAT) );
spAxisY->put_Format( CComBSTR(defSTR_Y_AXIS_FORMAT) );
// Set X,Y Range
double dXMin,dXMax, dYMin, dYMax;
m_pDMGraphCtrl->GetRange(&dXMin, &dXMax, &dYMin, &dYMax);
dYMax = 100.0;
m_pDMGraphCtrl->SetRange(defDEFAULT_XRANGE_MIN, defDEFAULT_XRANGE_MAX, dYMin, dYMax);
//Set the caption
BSTR bstrCaption(L"Graph Display - CAN");
m_pDMGraphCtrl->put_Caption(bstrCaption);
}
// Update Local DDX Variables
UpdateData( FALSE );
// Update Axis and action
vSetAction();
}
}
}
BOOL CVCAMetaParserMSXML::ParseObjects( )
{
// Find all the objects
CComBSTR bsTag;
MSXML2::IXMLDOMNodePtr pNode, pSubNode, pSubSubNode, pSubSubSubNode; // Great names eh ;~)
MSXML2::IXMLDOMNodeListPtr pNodeList, pSubNodeList;
// See if we have any objects this time round
bsTag = CComBSTR( _XML_VCA ) += CComBSTR("/") += CComBSTR( _XML_OBJECTS );
pNode = m_pDOMDoc->selectSingleNode( bsTag.operator BSTR() );
// ATLTRACE( "====================================================== \n" );
if( pNode )
{
// There are some in this packet
// Wipe out all exisiting
m_vcaObjects.ulTotalObject = 0;
// Select all objects
bsTag = CComBSTR( _XML_OBJECT );
pNodeList = pNode->selectNodes( bsTag.operator BSTR() );
// Iterate through all the nodes
pNode = pNodeList->nextNode();
while( pNode )
{
VCA5_PACKET_OBJECT vcaObj;
memset( &vcaObj, 0, sizeof( vcaObj ) );
// Id
bsTag = CComBSTR( _XML_ID );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&vcaObj.ulId );
}
// Calibrated height and speed
bsTag = CComBSTR( _XML_CH );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&vcaObj.ulCalibHeight);
}
bsTag = CComBSTR( _XML_CS );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&vcaObj.ulCalibSpeed);
}
bsTag = CComBSTR( _XML_CA );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&vcaObj.ulCalibArea);
}
bsTag = CComBSTR( _XML_CLS );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (long *)&vcaObj.iClassificationId);
}
else
{
vcaObj.iClassificationId = -2; // unknown
}
bsTag = CComBSTR( _XML_COLSIG );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
std::string tempColSigs = pSubNode->text;
for(int n=0; n<VCA5_APP_PALETTE_SIZE; n++)
{
vcaObj.colSigs[n] = (UCHAR)strtoul( tempColSigs.substr(n*2,2).c_str(), NULL, 16 );
}
// ATLTRACE( "%s: %d %d %d %d %d %d %d %d %d %d \n", tempColSigs.c_str(),
// vcaObj.colSigs[0], vcaObj.colSigs[1], vcaObj.colSigs[2], vcaObj.colSigs[3], vcaObj.colSigs[4],
// vcaObj.colSigs[5], vcaObj.colSigs[6], vcaObj.colSigs[7], vcaObj.colSigs[8], vcaObj.colSigs[9] );
}
else
{
for(int n=0; n<VCA5_APP_PALETTE_SIZE; n++)
{
vcaObj.colSigs[n] = 0;
}
}
// Bounding box
ParseBBox( pNode, &vcaObj.bBox );
// Trail
bsTag = CComBSTR( _XML_TRAIL );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
bsTag = CComBSTR( _XML_PT );
pSubNodeList = pSubNode->selectNodes( bsTag.operator BSTR() );
pSubSubNode = pSubNodeList->nextNode();
vcaObj.trail.usNumTrailPoints = 0;
while( pSubSubNode )
{
VCA5_POINT vcaPoint;
memset( &vcaPoint, 0, sizeof( vcaPoint ) );
bsTag = CComBSTR( _XML_X );
pSubSubSubNode = pSubSubNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubSubSubNode )
{
VarUI2FromStr( pSubSubSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned short *)&vcaPoint.x );
}
bsTag = CComBSTR( _XML_Y );
pSubSubSubNode = pSubSubNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubSubSubNode )
{
VarUI2FromStr( pSubSubSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned short *)&vcaPoint.y);
}
// Ph it (like Salt 'n' Pepa)
vcaObj.trail.trailPoints[vcaObj.trail.usNumTrailPoints] = vcaPoint;
vcaObj.trail.usNumTrailPoints++;
pSubSubNode = pSubNodeList->nextNode();
}
}
// Flags
bsTag = CComBSTR( _XML_FLAGS );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&vcaObj.ulFlags );
}
m_vcaObjects.Objects[m_vcaObjects.ulTotalObject] = vcaObj;
//m_vcaObjects.ph_back( vcaObj );
m_vcaObjects.ulTotalObject++;
pNode = pNodeList->nextNode();
}
}
return TRUE;
}
HRESULT AbstractDeviceContent::WriteValue(
REFPROPERTYKEY Key,
const PROPVARIANT& Value)
{
HRESULT hr = S_OK;
PropVariantWrapper pvValue;
if(IsEqualPropertyKey(Key, WPD_OBJECT_NAME))
{
if(Value.vt == VT_LPWSTR)
{
if (wcslen(Value.pwszVal) > 0)
{
Name = Value.pwszVal;
}
else
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Failed to set WPD_OBJECT_NAME because value was an empty string");
}
}
else
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Failed to set WPD_OBJECT_NAME because type was not VT_LPWSTR");
}
}
else
{
hr = E_ACCESSDENIED;
CHECK_HR(hr, "Property %ws.%d on [%ws] does not support set value operation", CComBSTR(Key.fmtid), Key.pid, ObjectID);
}
return hr;
}
BOOL CVCAMetaParserMSXML::ParseEvents()
{
// Find all the events
USES_CONVERSION;
CComBSTR bsTag;
MSXML2::IXMLDOMNodePtr pNode, pSubNode, pSubSubNode, pSubSubSubNode; // Great names eh ;~)
MSXML2::IXMLDOMNodeListPtr pNodeList, pSubNodeList;
// See if we have any objects this time round
bsTag = CComBSTR( _XML_VCA ) += CComBSTR("/") += CComBSTR( _XML_EVENTS );
pNode = m_pDOMDoc->selectSingleNode( bsTag.operator BSTR() );
if( pNode )
{
// There are some event specified in this packet... take a look...
m_vcaEvents.ulTotalEvents = 0;
// Select all events
bsTag = CComBSTR( _XML_EVENT );
pNodeList = pNode->selectNodes( bsTag.operator BSTR() );
// Iterate through all the nodes
pNode = pNodeList->nextNode();
while( pNode )
{
VCA5_PACKET_EVENT vcaEvent;
memset( &vcaEvent, 0, sizeof( VCA5_PACKET_EVENT ) );
// <type>
bsTag = CComBSTR( _XML_TYPE );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
if( 0 == strcmp( pSubNode->text, "zone")) vcaEvent.ulEventType = VCA5_EVENT_TYPE_ZONE;
else if( 0 == strcmp( pSubNode->text, "tamper")) vcaEvent.ulEventType = VCA5_EVENT_TYPE_TAMPER;
}
switch (vcaEvent.ulEventType)
{
case VCA5_EVENT_TYPE_TAMPER:
m_uTamperAlarm = 300;
strcpy( vcaEvent.szRuleName, "---" );
strcpy( vcaEvent.szZoneName, "---" );
break;
// Deliberate fall-thru (durchfall :)
case VCA5_EVENT_TYPE_ZONE:
// <id>
bsTag = CComBSTR( _XML_ID );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&vcaEvent.ulId );
}
// <rule_name>
// TBD
// <rule_id>
bsTag = CComBSTR( _XML_RULE_ID );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&vcaEvent.ulRuleId );
}
// <rule_name>
bsTag = CComBSTR( _XML_RULE_NAME );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
strcpy( vcaEvent.szRuleName, CT2A(pSubNode->text , CP_UTF8) );
}
else
{
strcpy( vcaEvent.szRuleName, "---" );
}
// <obj_id> (multiple)
bsTag = CComBSTR( _XML_OBJ_ID );
pSubNodeList = pNode->selectNodes( bsTag.operator BSTR() );
if( pSubNodeList )
{
pSubNode = pSubNodeList->nextNode();
if( pSubNode )
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&vcaEvent.ulObjId );
}
// <zone_id> (multiple)
bsTag = CComBSTR( _XML_ZONE_ID );
pSubNodeList = pNode->selectNodes( bsTag.operator BSTR() );
if( pSubNodeList )
{
pSubNode = pSubNodeList->nextNode();
while( pSubNode )
{
unsigned int uiZoneId;
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&uiZoneId );
vcaEvent.ulZoneId = uiZoneId;
break;
pSubNode = pSubNodeList->nextNode();
}
}
// <zone_name> (multiple)
bsTag = CComBSTR( _XML_ZONE_NAME );
pSubNodeList = pNode->selectNodes( bsTag.operator BSTR() );
if( pSubNodeList )
{
pSubNode = pSubNodeList->nextNode();
while( pSubNode )
{
std::string szZoneName;
szZoneName = pSubNode->text;
strcpy( vcaEvent.szZoneName, szZoneName.c_str());
// Assume only 1
break;
pSubNode = pSubNodeList->nextNode();
}
}
/*
// <obj_id> (multiple)
bsTag = CComBSTR( _XML_OBJ_ID );
pSubNodeList = pNode->selectNodes( bsTag.operator BSTR() );
if( pSubNodeList )
{
pSubNode = pSubNodeList->nextNode();
while( pSubNode )
{
unsigned int uiObjId;
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&uiObjId );
vcaEvent.vObjIds.push_back( uiObjId );
pSubNode = pSubNodeList->nextNode();
}
}
// <obj_cls_name> (multiple)
bsTag = CComBSTR( _XML_OBJ_CLS_NAME );
pSubNodeList = pNode->selectNodes( bsTag.operator BSTR() );
if( pSubNodeList )
{
pSubNode = pSubNodeList->nextNode();
while( pSubNode )
{
std::string szObjClsName;
szObjClsName = pSubNode->text;
vcaEvent.vObjClsNames.push_back( szObjClsName );
pSubNode = pSubNodeList->nextNode();
}
}
*/
// <status>
bsTag = CComBSTR( _XML_STATUS );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&vcaEvent.ulStatus );
}
// <start_time>
bsTag = CComBSTR( _XML_START_TIME ) += CComBSTR("/") += CComBSTR( _XML_S );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
//time_t tTime;
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&vcaEvent.tStartTime.ulSec );
//vcaEvent.tStartTime = CTime( tTime );
}
bsTag = CComBSTR( _XML_START_TIME ) += CComBSTR("/") += CComBSTR( _XML_MS );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
//time_t tTime;
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&vcaEvent.tStartTime.ulMSec );
//vcaEvent.tStartTime = CTime( tTime );
}
// <end_time>
bsTag = CComBSTR( _XML_END_TIME ) += CComBSTR("/") += CComBSTR( _XML_S );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
//time_t tTime;
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&vcaEvent.tStopTime.ulSec );
//vcaEvent.tStopTime = CTime( tTime );
}
bsTag = CComBSTR( _XML_END_TIME ) += CComBSTR("/") += CComBSTR( _XML_MS );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
//time_t tTime;
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&vcaEvent.tStopTime.ulMSec );
//vcaEvent.tStopTime = CTime( tTime );
}
// Bounding box
ParseBBox( pNode, &vcaEvent.bBox );
m_vcaEvents.Events[m_vcaEvents.ulTotalEvents] = vcaEvent;
m_vcaEvents.ulTotalEvents++;
break;
default: break;
}
pNode = pNodeList->nextNode();
}
}
return TRUE;
}
STDMETHODIMP CStrokeRecognition::put_RecognitionParam(BSTR newVal)
{
double Segment_Error_Threshold;
double Arc_Error_Threshold;
double Arc_Min_Length;
double Arc_Min_Curve;
double Stroke_Min_Length;
double Min_Turning_Angle;
double Segmentation_Penalty;
VARIANT value;
BSTR nodeName;
long n;
IXMLDOMDocument* pDoc;
IXMLDOMNodeList* pNodeList;
IXMLDOMNode* pNode;
IXMLDOMNode* pParamNode;
IXMLDOMNode* pAttrNode;
IXMLDOMNamedNodeMap* pNodeMap;
VARIANT_BOOL bLoaded;
GetFittingParam(Segment_Error_Threshold, Arc_Error_Threshold, Arc_Min_Length, Arc_Min_Curve, Stroke_Min_Length, Min_Turning_Angle, Segmentation_Penalty);
if (SUCCEEDED(CoCreateInstance(CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument, (LPVOID*)&pDoc)))
{
pDoc->put_async(VARIANT_FALSE);
pDoc->loadXML(newVal, &bLoaded);
if (bLoaded == VARIANT_TRUE)
{
if (SUCCEEDED(pDoc->get_childNodes(&pNodeList)))
{
pParamNode = NULL;
pNodeList->get_length(&n);
for (int i = 0; i < n; i++)
{
if (SUCCEEDED(pNodeList->get_item(i, &pNode)))
{
nodeName = NULL;
if (SUCCEEDED(pNode->get_nodeName(&nodeName)))
{
if (CComBSTR(nodeName) == L"param")
{
pParamNode = pNode;
pParamNode->AddRef();
break;
}
SysFreeString(nodeName);
}
pNode->Release();
}
}
pNodeList->Release();
if (pParamNode != NULL)
{
if (SUCCEEDED(pParamNode->get_attributes(&pNodeMap)))
{
if (SUCCEEDED(pNodeMap->getNamedItem(L"Segment_Error_Threshold", &pAttrNode)))
{
pAttrNode->get_nodeValue(&value);
Segment_Error_Threshold = _wtof(value.bstrVal);
pAttrNode->Release();
}
if (SUCCEEDED(pNodeMap->getNamedItem(L"Arc_Error_Threshold", &pAttrNode)))
{
pAttrNode->get_nodeValue(&value);
Arc_Error_Threshold = _wtof(value.bstrVal);
pAttrNode->Release();
}
if (SUCCEEDED(pNodeMap->getNamedItem(L"Arc_Min_Length", &pAttrNode)))
{
pAttrNode->get_nodeValue(&value);
Arc_Min_Length = _wtof(value.bstrVal);
pAttrNode->Release();
}
if (SUCCEEDED(pNodeMap->getNamedItem(L"Arc_Min_Curve", &pAttrNode)))
{
pAttrNode->get_nodeValue(&value);
Arc_Min_Curve = _wtof(value.bstrVal);
pAttrNode->Release();
}
if (SUCCEEDED(pNodeMap->getNamedItem(L"Stroke_Min_Length", &pAttrNode)))
{
pAttrNode->get_nodeValue(&value);
Stroke_Min_Length = _wtof(value.bstrVal);
pAttrNode->Release();
}
if (SUCCEEDED(pNodeMap->getNamedItem(L"Min_Turning_Angle", &pAttrNode)))
{
pAttrNode->get_nodeValue(&value);
Min_Turning_Angle = _wtof(value.bstrVal);
pAttrNode->Release();
}
if (SUCCEEDED(pNodeMap->getNamedItem(L"Segmentation_Penalty", &pAttrNode)))
{
pAttrNode->get_nodeValue(&value);
Segmentation_Penalty = _wtof(value.bstrVal);
pAttrNode->Release();
}
pNodeMap->Release();
}
pParamNode->Release();
}
}
}
pDoc->Release();
}
SetFittingParam(Segment_Error_Threshold, Arc_Error_Threshold, Arc_Min_Length, Arc_Min_Curve, Stroke_Min_Length, Min_Turning_Angle, Segmentation_Penalty);
return S_OK;
}
BOOL CVCAMetaParserMSXML::ParseBBox( MSXML2::IXMLDOMNodePtr pNode, VCA5_RECT *pBbox )
{
MSXML2::IXMLDOMNodePtr pSubNode;
CComBSTR bsTag;
// Bounding Box
bsTag = CComBSTR( _XML_BB ) += CComBSTR("/") += CComBSTR( _XML_X );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI2FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned short *)&pBbox->x );
}
bsTag = CComBSTR( _XML_BB ) += CComBSTR("/") += CComBSTR( _XML_Y );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI2FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned short *)&pBbox->y );
}
bsTag = CComBSTR( _XML_BB ) += CComBSTR("/") += CComBSTR( _XML_W );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI2FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned short *)&pBbox->w );
}
bsTag = CComBSTR( _XML_BB ) += CComBSTR("/") += CComBSTR( _XML_H );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI2FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned short *)&pBbox->h);
}
return TRUE;
}
STDMETHODIMP CShowWindowCommand::GetCommandText(REFGUID guidCommand, BSTR* bstrText)
{
CHECK_E_POINTER(bstrText);
*bstrText = CComBSTR(L"Settings...");
return S_OK;
}
//---------------------------------------------------------------------------
BOOL CVCAMetaParserMSXML::ParseCE( )
{
CComBSTR bsTag;
MSXML2::IXMLDOMNodePtr pNode, pSubNode, pSubSubNode; // Great names eh ;~)
MSXML2::IXMLDOMNodeListPtr pNodeList;
// See if we have any objects this time round
bsTag = CComBSTR( _XML_VCA ) += CComBSTR("/") += CComBSTR( _XML_COUNTEVENTS );
pNode = m_pDOMDoc->selectSingleNode( bsTag.operator BSTR() );
if( pNode )
{
// There are some event specified in this packet... take a look...
memset(&m_vcaCountLineEvents, 0, sizeof(m_vcaCountLineEvents));
// Select all events
bsTag = CComBSTR( _XML_CE );
pNodeList = pNode->selectNodes( bsTag.operator BSTR() );
// Iterate through all the nodes
pNode = pNodeList->nextNode();
while( pNode )
{
VCA5_COUNTLINE_EVENT clEvent;
memset( &clEvent, 0, sizeof( VCA5_COUNTLINE_EVENT ) );
// pClEvent
bsTag = CComBSTR( _XML_ID );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&clEvent.uiId );
}
bsTag = CComBSTR( _XML_P );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI2FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned short *)&clEvent.usPos );
}
bsTag = CComBSTR( _XML_W );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI2FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned short *)&clEvent.usWidth );
}
bsTag = CComBSTR( _XML_N );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI2FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned short *)&clEvent.usNum );
}
m_vcaCountLineEvents.CountLineEvents[m_vcaCountLineEvents.ulTotalCountLineEvents] = clEvent;
m_vcaCountLineEvents.ulTotalCountLineEvents++;
pNode = pNodeList->nextNode();
}
}
return TRUE;
}
void CMSDNForumHelper::RevealHiddenLinks(IHTMLDocument2* pDocument)
{
CComBSTR url;
HRESULT hr=pDocument->get_URL(&url);
if(hr==S_OK)
{
url.ToLower();
CString urlString(url);
if(urlString.Find(_T("microsoft.com"))==-1)
return;
if(urlString.Find(_T("social"))==1)
return;
}
CComPtr<IHTMLElementCollection> linkElementCollection;
// Get the collection of images from the DOM.
hr = pDocument->get_links(&linkElementCollection);
if (hr == S_OK && linkElementCollection != NULL)
{
// Get the number of images in the collection.
long linkCount = 0;
hr = linkElementCollection->get_length(&linkCount);
if (hr == S_OK && linkCount > 0)
{
for (int i = 0; i < linkCount; i++)
{
CComVariant varItemIndex(i);
CComVariant varEmpty;
CComPtr<IDispatch> linkDispatch;
// Get the link out of the collection by index.
hr = linkElementCollection->item(varItemIndex, varEmpty, &linkDispatch);
if (hr == S_OK && linkDispatch != NULL)
{
//filter out hot spot on images
CComQIPtr<IHTMLAnchorElement> anchorElement(linkDispatch);
if(anchorElement==NULL) continue;
//query for the generic HTML element interface
CComQIPtr<IHTMLElement> linkElement(linkDispatch);
if (linkElement)
{
// ...then ask for the style interface.
CComPtr<IHTMLStyle> linkStyle;
hr = linkElement->get_style(&linkStyle);
// Set display="none" to hide the image.
if (hr == S_OK && linkStyle != NULL)
{
CComVariant linkCollor;
hr=linkStyle->get_color(&linkCollor);
if(linkCollor.vt==VT_BSTR)
{
CComBSTR linkCollorString(linkCollor.bstrVal);
if (hr == S_OK && linkCollorString.Length()>0)
{
linkStyle->put_backgroundColor(CComVariant(_T("red")));
linkStyle->put_color(CComVariant(_T("")));
CComBSTR href,text;
anchorElement->get_href(&href);
linkElement->get_innerText(&text);
CString newText;
newText.Format(_T("hidden link, possible spam: text: %s, url: %s"),text,href);
linkElement->put_innerText(CComBSTR(newText));
}
}
}
}
}
}
}
}
}
BOOL CVCAMetaParserMSXML::ParseBlobsImp(char* szTag, VCA5_PACKET_BLOBMAP *pBLOBMAP)
{
CComBSTR bsTag;
MSXML2::IXMLDOMNodePtr pNode, pSubNode; // Great names eh ;~)
MSXML2::IXMLDOMNodeListPtr pNodeList, pSubNodeList;
unsigned int uiWidth = 0, uiHeight = 0;
// See if we have any objects this time round
bsTag = CComBSTR( _XML_VCA ) += CComBSTR("/") += CComBSTR( szTag );
pNode = m_pDOMDoc->selectSingleNode( bsTag.operator BSTR() );
if( pNode )
{
// Tampermap is there
bsTag = CComBSTR( _XML_W );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&uiWidth );
}
bsTag = CComBSTR( _XML_H );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
VarUI4FromStr( pSubNode->text, LCID_ENGLISH, LOCALE_NOUSEROVERRIDE, (unsigned long *)&uiHeight );
}
if( uiWidth != pBLOBMAP->ulWidth || uiHeight != pBLOBMAP->ulHeight )
{
if (pBLOBMAP->pBlobMap)
delete [] pBLOBMAP->pBlobMap;
pBLOBMAP->pBlobMap = new unsigned char[ uiWidth * (uiHeight+1) ];
pBLOBMAP->ulWidth = uiWidth;
pBLOBMAP->ulHeight = uiHeight;
}
// Now look for the data
bsTag = CComBSTR( _XML_DATA );
pSubNode = pNode->selectSingleNode( bsTag.operator BSTR() );
if( pSubNode )
{
unsigned char *pBlobMap = pBLOBMAP->pBlobMap;
// Demunge the data
CString s( (LPCWSTR) pSubNode->text );
TCHAR *pS = s.GetBuffer(0);
int len = s.GetLength();
for( int i = 0; i < s.GetLength(); i++ )
{
char cc = (char)pS[i];
unsigned char ucBits = m_base64[pS[i]];
*pBlobMap++ = ucBits & 0x01 ? 1 : 0;
*pBlobMap++ = ucBits & 0x02 ? 1 : 0;
*pBlobMap++ = ucBits & 0x04 ? 1 : 0;
*pBlobMap++ = ucBits & 0x08 ? 1 : 0;
*pBlobMap++ = ucBits & 0x10 ? 1 : 0;
*pBlobMap++ = ucBits & 0x20 ? 1 : 0;
}
}
pBLOBMAP->ulMapAge = 0;
}else{
pBLOBMAP->ulMapAge++;
// we shoud get map update every 2nd frame
// if map is 2 frames old so clean it up or else we get old map hanging around
if ( pBLOBMAP->ulMapAge == 2 && pBLOBMAP->pBlobMap )
{
memset( pBLOBMAP->pBlobMap, 0, pBLOBMAP->ulWidth * pBLOBMAP->ulHeight );
}
}
return TRUE;
}
void CIntelBottomView::OnDraw(CDC* dc)
{
CBotEDoc* pDoc = resources::pDoc;
AssertBotE(pDoc);
if (!pDoc->m_bDataReceived)
return;
CMajor* pMajor = m_pPlayersRace;
AssertBotE(pMajor);
if (!pMajor)
return;
// TODO: add draw code here
// Doublebuffering wird initialisiert
CMyMemDC pDC(dc);
CRect client;
GetClientRect(&client);
// Graphicsobjekt, in welches gezeichnet wird anlegen
Graphics g(pDC->GetSafeHdc());
g.Clear(static_cast<Gdiplus::ARGB>(Color::Black));
g.SetSmoothingMode(SmoothingModeHighSpeed);
g.SetInterpolationMode(InterpolationModeLowQuality);
g.SetPixelOffsetMode(PixelOffsetModeHighSpeed);
g.SetCompositingQuality(CompositingQualityHighSpeed);
g.ScaleTransform((REAL)client.Width() / (REAL)m_TotalSize.cx, (REAL)client.Height() / (REAL)m_TotalSize.cy);
CString fontName = "";
Gdiplus::REAL fontSize = 0.0;
StringFormat fontFormat;
SolidBrush fontBrush(static_cast<Gdiplus::ARGB>(Color::White));
Color color;
color.SetFromCOLORREF(pMajor->GetDesign()->m_clrGalaxySectorText);
fontBrush.SetColor(color);
Bitmap* graphic = pDoc->GetGraphicPool()->GetGDIGraphic("Backgrounds\\" + pMajor->GetPrefix() + "diplomacyV3.boj");
// Grafik zeichnen
if (graphic)
{
g.DrawImage(graphic, 0, 0, 1075, 249);
graphic = NULL;
}
// Nur in bestimmten Submenüs werden in der View3 Berichte angezeigt
BYTE curIntelSubMenu = resources::pMainFrame->GetSubMenu(RUNTIME_CLASS(CIntelMenuView));
if (curIntelSubMenu == 4 || curIntelSubMenu == 5)
{
CRect r;
r.SetRect(0,0,m_TotalSize.cx,m_TotalSize.cy);
short n = pMajor->GetEmpire()->GetIntelligence()->GetIntelReports()->GetActiveReport();
if (n != -1)
{
CFontLoader::CreateGDIFont(pMajor, 4, fontName, fontSize);
fontFormat.SetAlignment(StringAlignmentNear);
fontFormat.SetLineAlignment(StringAlignmentNear);
fontFormat.SetFormatFlags(StringFormatFlagsNoWrap);
CIntelObject* report = pMajor->GetEmpire()->GetIntelligence()->GetIntelReports()->GetReport(n);
CString s;
if (report->GetIsSpy())
s = CLoc::GetString("SPY");
else
s = CLoc::GetString("SABOTAGE");
g.DrawString(CComBSTR(s), -1, &Gdiplus::Font(CComBSTR(fontName), fontSize), RectF(40, 40, r.right-100, r.bottom-20), &fontFormat, &fontBrush);
CFontLoader::CreateGDIFont(pMajor, 2, fontName, fontSize);
fontBrush.SetColor(Color(200,200,250));
fontFormat.SetFormatFlags(!StringFormatFlagsNoWrap);
if (report->GetOwner() == pMajor->GetRaceID())
s = *report->GetOwnerDesc();
else
s = *report->GetEnemyDesc();
g.DrawString(CComBSTR(s), -1, &Gdiplus::Font(CComBSTR(fontName), fontSize), RectF(40, 100, r.right-250, r.bottom-20), &fontFormat, &fontBrush);
}
}
g.ReleaseHDC(pDC->GetSafeHdc());
}
int parseCommandLine() {
int iRet = 0;
int iNumArgs, iNumToBeProcessed;
LPTSTR lpstrCommandArgs=GetCommandLine();
LPTSTR *rgCmdArgs=CommandLineToArgvW(lpstrCommandArgs,&iNumArgs);
// To take care of no command line arguments
if (iNumArgs <= 1 ) {
iRet = -1;
goto Cleanup;
}
// Check if one argument only and that is the /? argument
if (0==_tcsncicmp(rgCmdArgs[1],CAzGlobalOptions::HELPTAG , CAzGlobalOptions::HELPTAG_LEN)) {
DisplayUsage();
iRet = 1;
goto Cleanup;
}
// if more than one argument but not the required 2 arguments
if (iNumArgs < 3 ) {
iRet = -1;
goto Cleanup;
}
CAzGlobalOptions::m_bstrDestStoreName.Attach(CComBSTR(rgCmdArgs[1]).Copy());
CAzGlobalOptions::m_bstrSourceStoreName.Attach(CComBSTR(rgCmdArgs[2]).Copy());
CAzGlobalOptions::setDefaults();
iNumToBeProcessed = iNumArgs-3;
for (int i = 3 ; i < iNumArgs ; i++) {
// Checking for /logfile
if (0==_tcsncicmp(rgCmdArgs[i],CAzGlobalOptions::LOGFILETAG,CAzGlobalOptions::LOGFILETAG_LEN)) {
_TCHAR *strRightPart=_tcschr(rgCmdArgs[i],_TCHAR('='));
if (NULL==strRightPart) {
iRet = -1;
goto Cleanup;
}
CAzLogging::Initialize(CAzLogging::LOG_LOGFILE,&strRightPart[1]);
iNumToBeProcessed--;
} else if (0==_tcsncicmp(rgCmdArgs[i],CAzGlobalOptions::APPNAMETAG,CAzGlobalOptions::APPNAMETAG_LEN)) {
//Checking for /application flag
LPTSTR strTmp;
_TCHAR *strRightPart=_tcschr(rgCmdArgs[i],_TCHAR('='));
if (NULL==strRightPart) {
iRet = -1;
goto Cleanup;
}
CAzGlobalOptions::m_bSpecificApp=true;
_TCHAR *strAppNames =_tcstok_s(&strRightPart[1],_TEXT(","),&strTmp);
while (strAppNames!=NULL) {
CAzGlobalOptions::m_bstrAppNames.push_back(CComBSTR(strAppNames).Copy());
/* While there are tokens in "string" */
/* Get next token: */
strAppNames =_tcstok_s(NULL,_TEXT(","),&strTmp);
}
iNumToBeProcessed--;
} else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::OVERWRITETAG , CAzGlobalOptions::OVERWRITETAG_LEN)) {
//Checking for /overwrite flag
CAzGlobalOptions::m_bOverWrite=true;
iNumToBeProcessed--;
} else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::IGNOREMEMBERSTAG,CAzGlobalOptions::IGNOREMEMBERSTAG_LEN)) {
//Checking for /IGNOREMEMBERS flag
CAzGlobalOptions::m_bIgnoreMembers=true;
iNumToBeProcessed--;
} else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::IGNOREPOLICYADMINSTAG , CAzGlobalOptions::IGNOREPOLICYADMINSTAG_LEN)) {
//Checking for /IGNOREPOLICYADMIN flag
CAzGlobalOptions::m_bIgnorePolicyAdmins=true;
iNumToBeProcessed--;
} else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::VERBOSETAG , CAzGlobalOptions::VERBOSETAG_LEN)) {
CAzGlobalOptions::m_bVerbose=true;
CAzLogging::Initialize(CAzLogging::LOG_TRACE);
iNumToBeProcessed--;
} else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::HELPTAG , CAzGlobalOptions::HELPTAG_LEN)) {
DisplayUsage();
iNumToBeProcessed--;
iRet = 1;
goto Cleanup;
}
}
// Some additional parameters exist which donot match
// hence these are invalid flags.
if (0 != iNumToBeProcessed)
{
iRet = -1;
goto Cleanup;
}
iRet = 0;
Cleanup:
if (rgCmdArgs)
{
LocalFree(rgCmdArgs);
}
return iRet;
}
extern "C" __declspec(dllexport) bool PinToStartMenu4XP(bool bPin, char* szPath)
{
TSAUTO();
TCHAR file_dir[MAX_PATH + 1] = {0};
TCHAR *file_name;
wchar_t* pwstr_Path = AnsiToUnicode(szPath);
if(pwstr_Path == NULL){
return false;
}
wcscpy_s(file_dir,MAX_PATH,pwstr_Path);
PathRemoveFileSpecW(file_dir);
file_name = PathFindFileName(pwstr_Path);
::CoInitialize(NULL);
CComPtr<IShellDispatch> pShellDisp;
CComPtr<Folder> folder_ptr;
CComPtr<FolderItem> folder_item_ptr;
CComPtr<FolderItemVerbs> folder_item_verbs_ptr;
HRESULT rv = CoCreateInstance( CLSID_Shell, NULL, CLSCTX_SERVER,IID_IDispatch, (LPVOID *) &pShellDisp );
do
{
IF_FAILED_OR_NULL_BREAK(rv,pShellDisp);
rv = pShellDisp->NameSpace(_variant_t(file_dir),&folder_ptr);
IF_FAILED_OR_NULL_BREAK(rv,folder_ptr);
rv = folder_ptr->ParseName(CComBSTR(file_name),&folder_item_ptr);
IF_FAILED_OR_NULL_BREAK(rv,folder_item_ptr);
rv = folder_item_ptr->Verbs(&folder_item_verbs_ptr);
IF_FAILED_OR_NULL_BREAK(rv,folder_item_verbs_ptr);
long count = 0;
folder_item_verbs_ptr->get_Count(&count);
for (long i = 0; i < count ; ++i)
{
FolderItemVerb* item_verb = NULL;
rv = folder_item_verbs_ptr->Item(_variant_t(i),&item_verb);
if (SUCCEEDED(rv) && item_verb)
{
CComBSTR bstrName;
item_verb->get_Name(&bstrName);
if ( VerbNameMatch(bstrName,bPin) )
{
TSDEBUG4CXX("Find Verb to Pin:"<< bstrName);
int i = 0;
do
{
rv = item_verb->DoIt();
TSDEBUG4CXX("Try Do Verb. NO." << i+1 << ", return="<<rv);
if (SUCCEEDED(rv))
{
::SHChangeNotify(SHCNE_UPDATEDIR|SHCNE_INTERRUPT|SHCNE_ASSOCCHANGED, SHCNF_IDLIST |SHCNF_FLUSH | SHCNF_PATH|SHCNE_ASSOCCHANGED,
pwstr_Path,0);
Sleep(500);
delete [] pwstr_Path;
::CoUninitialize();
return true;
}else
{
Sleep(500);
rv = item_verb->DoIt();
}
}while ( i++ < 3);
break;
}
}
}
} while (0);
delete [] pwstr_Path;
::CoUninitialize();
return false;
}
HRESULT ExchangeAdmin::CreateExchangeMailBox(LPCWSTR lpwstrNewUser, LPCWSTR lpwstrNewUserPwd,
LPCWSTR lpwstrlogonuser, LPCWSTR lpwstrLogonUsrPwd)
{
HRESULT hr = S_OK;
// Get Logon user DN
wstring LogonUserDN;
wstring legacyName;
wstring msExchHomeSvrName;
Zimbra::MAPI::Util::GetUserDNAndLegacyName(m_strServer.c_str(), lpwstrlogonuser,
lpwstrLogonUsrPwd, LogonUserDN, legacyName);
Zimbra::MAPI::Util::GetmsExchHomeServerName(m_strServer.c_str(), lpwstrlogonuser,
lpwstrLogonUsrPwd, msExchHomeSvrName);
Zimbra::Util::ScopedInterface<IDirectoryObject> pLogonContainer;
Zimbra::Util::ScopedInterface<IADsUser> pIAdUser;
Zimbra::Util::ScopedInterface<IADs> pIAds;
wstring strContainer = L"LDAP://";
strContainer += LogonUserDN.c_str();
dloge("strContainer %S msExchHomeSvrName: %S", strContainer.c_str(), msExchHomeSvrName.c_str());
// Get loggedin user container
hr = ADsOpenObject(strContainer.c_str(), NULL, NULL, ADS_SECURE_AUTHENTICATION,
IID_IDirectoryObject, (void **)pLogonContainer.getptr());
if (FAILED(hr))
{
if (hr == 0x8007052e) // credentials are not valid
{
hr = ADsOpenObject((LPTSTR)strContainer.c_str(), lpwstrlogonuser, lpwstrLogonUsrPwd,
ADS_SECURE_AUTHENTICATION, IID_IDirectoryObject, (void **)pLogonContainer.getptr());
if (FAILED(hr)||(pLogonContainer.get()==NULL))
throw ExchangeAdminException(hr,L"CreateExchangeMailBox(): ADsOpenObject Failed.",
ERR_ADOBJECT_OPEN, __LINE__, __FILE__);
}
else
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): ADsOpenObject Failed.",
ERR_ADOBJECT_OPEN, __LINE__, __FILE__);
}
}
ADS_ATTR_INFO *pAttrInfo = NULL;
DWORD dwReturn;
LPWSTR pAttrNames[] = { L"mail", L"homeMDB", L"homeMTA" };
DWORD dwNumAttr = sizeof (pAttrNames) / sizeof (LPWSTR);
wstring strLogonHomeMDB;
wstring strLogonHomeMTA;
wstring strLogonMail;
// Get attribute values requested. Its not necessary the order is same as requested.
if (FAILED(hr = pLogonContainer->GetObjectAttributes(pAttrNames, dwNumAttr, &pAttrInfo,
&dwReturn)))
throw ExchangeAdminException(hr,L"CreateExchangeMailBox(): GetObjectAttributes Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
for (DWORD idx = 0; idx < dwReturn; idx++)
{
if (_wcsicmp(pAttrInfo[idx].pszAttrName, L"mail") == 0)
strLogonMail = pAttrInfo[idx].pADsValues->Email.Address;
else if (_wcsicmp(pAttrInfo[idx].pszAttrName, L"homeMTA") == 0)
strLogonHomeMTA = pAttrInfo[idx].pADsValues->DNString;
else if (_wcsicmp(pAttrInfo[idx].pszAttrName, L"homeMDB") == 0)
strLogonHomeMDB = pAttrInfo[idx].pADsValues->DNString;
}
// Use FreeADsMem for all memory obtained from the ADSI call.
FreeADsMem(pAttrInfo);
wstring twtsrlogonuserDN = LogonUserDN;
size_t nPos = twtsrlogonuserDN.find(_T("DC="), 0);
wstring wstrServerDN = twtsrlogonuserDN.substr(nPos);
wstring wstrADSPath = _T("LDAP://CN=Users,") + wstrServerDN;
ADSVALUE cnValue;
ADSVALUE classValue;
ADSVALUE sAMValue;
ADSVALUE uPNValue;
ADSVALUE controlValue;
ADS_ATTR_INFO attrInfo[] = {
{ L"objectClass", ADS_ATTR_UPDATE, ADSTYPE_CASE_IGNORE_STRING, &classValue, 1 },
{ L"cn", ADS_ATTR_UPDATE, ADSTYPE_CASE_IGNORE_STRING, &cnValue, 1 },
{ L"sAMAccountName", ADS_ATTR_UPDATE, ADSTYPE_CASE_IGNORE_STRING, &sAMValue, 1 },
{ L"userPrincipalName", ADS_ATTR_UPDATE, ADSTYPE_CASE_IGNORE_STRING, &uPNValue, 1 },
{L"userAccountControl", ADS_ATTR_UPDATE, ADSTYPE_INTEGER,&controlValue, 1},
};
DWORD dwAttrs = sizeof (attrInfo) / sizeof (ADS_ATTR_INFO);
classValue.dwType = ADSTYPE_CASE_IGNORE_STRING;
classValue.CaseIgnoreString = L"user";
//int UF_ACCOUNTDISABLE = 0x0002;
int UF_PASSWD_NOTREQD = 0x0020;
//int UF_PASSWD_CANT_CHANGE = 0x0040;
int UF_NORMAL_ACCOUNT = 0x0200;
int UF_DONT_EXPIRE_PASSWD = 0x10000;
//int UF_PASSWORD_EXPIRED = 0x800000;
controlValue.dwType = ADSTYPE_INTEGER;
controlValue.Integer=UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD |UF_DONT_EXPIRE_PASSWD;
cnValue.dwType = ADSTYPE_CASE_IGNORE_STRING;
cnValue.CaseIgnoreString = (LPWSTR)lpwstrNewUser;
sAMValue.dwType = ADSTYPE_CASE_IGNORE_STRING;
sAMValue.CaseIgnoreString = (LPWSTR)lpwstrNewUser;
wstring wstrMail;
size_t nPosMail = strLogonMail.find(_T("@"), 0);
wstrMail = strLogonMail.substr(nPosMail);
wstrMail = lpwstrNewUser + wstrMail;
LPWSTR upnval = (LPWSTR)wstrMail.c_str();
uPNValue.dwType = ADSTYPE_CASE_IGNORE_STRING;
uPNValue.CaseIgnoreString = upnval;
Zimbra::Util::ScopedInterface<IDirectoryObject> pDirContainer;
Zimbra::Util::ScopedInterface<IDispatch> pDisp;
Zimbra::Util::ScopedInterface<IADsUser> pIADNewUser;
wstring wstrLoggedUserName(LogonUserDN);
size_t snPos = 0;
size_t enPos = 0;
if ((snPos = wstrLoggedUserName.find(L"CN=")) != wstring::npos)
{
if ((enPos = wstrLoggedUserName.find(L",", snPos)) != wstring::npos)
wstrLoggedUserName = wstrLoggedUserName.substr(snPos + 3, (enPos - (snPos + 3)));
}
// get dir container
if (FAILED(hr = ADsOpenObject(wstrADSPath.c_str(), wstrLoggedUserName.c_str(),
lpwstrLogonUsrPwd, ADS_SECURE_AUTHENTICATION, IID_IDirectoryObject,
(void **)pDirContainer.getptr())))
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): ADsOpenObject Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
wstring wstrUserCN = L"CN=";
wstrUserCN += lpwstrNewUser;
dloge("CreateDSObject: %S",wstrUserCN.c_str());
if (FAILED(hr = pDirContainer->CreateDSObject((LPWSTR)wstrUserCN.c_str(), attrInfo, dwAttrs,
pDisp.getptr())))
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): CreateDSObject Failed.",
ERR_CREATE_EXCHMBX,__LINE__, __FILE__);
if (FAILED(hr = pDisp->QueryInterface(IID_IADsUser, (void **)pIADNewUser.getptr())))
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): QueryInterface Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
CComVariant varProp;
varProp.Clear();
// set samAccount
varProp = lpwstrNewUser;
if (FAILED(hr = pIADNewUser->Put(CComBSTR(L"sAMAccountName"), varProp)))
throw ExchangeAdminException(hr,L"CreateExchangeMailBox(): Put(sAMAccountName) Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
if(FAILED(hr = pIADNewUser->SetInfo()))
throw ExchangeAdminException(hr,L"CreateExchangeMailBox(): Put(sAMAccountName) Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
// set userAccountControl
varProp.Clear();
hr = pIADNewUser->Get(CComBSTR(L"userAccountControl"), &varProp);
varProp = varProp.lVal & ~(ADS_UF_ACCOUNTDISABLE);
if (FAILED(hr = pIADNewUser->Put(CComBSTR(L"userAccountControl"), varProp)))
throw ExchangeAdminException(hr,L"CreateExchangeMailBox(): Put(userAccountControl) Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - Put(userAccountControl) Failed.");
// set Account enabled
if (FAILED(hr = pIADNewUser->put_AccountDisabled(VARIANT_FALSE)))
{
throw
ExchangeAdminException(hr, L"CreateExchangeMailBox(): put_AccountDisabled Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - put_AccountDisabled Failed.");
// set password
if (FAILED(hr = pIADNewUser->SetPassword(CComBSTR(lpwstrNewUserPwd))))
{
throw
ExchangeAdminException(hr, L"CreateExchangeMailBox(): SetPassword Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - SetPassword Failed.");
// user account password does not expire
varProp.Clear();
VARIANT var;
VariantInit(&var);
if (!FAILED(hr = pIADNewUser->Get(CComBSTR(L"userAccountControl"), &var)))
{
V_I4(&var) |= ADS_UF_DONT_EXPIRE_PASSWD;
if (FAILED(hr = pIADNewUser->Put(CComBSTR(L"userAccountControl"), var)))
{
throw ExchangeAdminException(hr,L"CreateExchangeMailBox(): Put(userAccountControl) Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
}
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - userAccountControl Failed.");
varProp.Clear();
// set the homeMDB;
if (!strLogonHomeMDB.empty())
{
varProp = strLogonHomeMDB.c_str();
if (FAILED(hr = pIADNewUser->Put(CComBSTR("homeMDB"), varProp)))
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Put(homeMDB) Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - Put(homeMDB) Failed.");
varProp.Clear();
if (!strLogonHomeMTA.empty())
{
varProp = strLogonHomeMTA.c_str();
if (FAILED(hr = pIADNewUser->Put(CComBSTR("homeMTA"), varProp)))
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Put(homeMTA) Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - Put(homeMTA) Failed.");
varProp.Clear();
if (!msExchHomeSvrName.empty())
{
varProp = msExchHomeSvrName.c_str();
if (FAILED(hr = pIADNewUser->Put(CComBSTR("msExchHomeServerName"), varProp)))
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Put(msExchHomeServerName) Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - Put(msExchHomeServerName) Failed.");
varProp.Clear();
varProp.Clear();
wstring newUsrLegacyName=legacyName;
size_t nwpos=newUsrLegacyName.rfind(L"cn=");
if(nwpos !=wstring::npos)
{
newUsrLegacyName = newUsrLegacyName.substr(0,nwpos);
newUsrLegacyName += L"cn=";
newUsrLegacyName += lpwstrNewUser;
}
if (!newUsrLegacyName.empty())
{
varProp = newUsrLegacyName.c_str();
if (FAILED(hr = pIADNewUser->Put(CComBSTR("legacyExchangeDN"), varProp)))
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Put(legacyExchangeDN) Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - Put(legacyExchangeDN) Failed.");
// set nickname
varProp.Clear();
varProp = lpwstrNewUser;
if (FAILED(hr = pIADNewUser->Put(CComBSTR("mailNickname"), varProp)))
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Put(mailNickname) Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - Put(mailNickname) Failed.");
// set the displayName
varProp.Clear();
varProp = lpwstrNewUser;
if (FAILED(hr = pIADNewUser->Put(CComBSTR("displayName"), varProp)))
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Put(displayName) Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - Put(displayName) Failed.");
// set the mail atrribute
varProp.Clear();
varProp = wstrMail.c_str();
if (FAILED(hr = pIADNewUser->Put(CComBSTR("mail"), varProp)))
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Put(mail) Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - Put(mail) Failed.");
// set email
if (FAILED(hr = pIADNewUser->put_EmailAddress(CComBSTR(wstrMail.c_str()))))
{
throw
ExchangeAdminException(hr, L"CreateExchangeMailBox(): put_EmailAddress Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - put_EmailAddress Failed.");
varProp.Clear();
wstrMail=L"SMTP:"+wstrMail;
varProp = wstrMail.c_str();
if (FAILED(hr = pIADNewUser->Put(CComBSTR("proxyAddresses"),varProp)))
{
throw
ExchangeAdminException(hr, L"CreateExchangeMailBox(): proxyAddressess Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - proxyAddressess Failed.");
// add to Domain Admins group
BSTR bstrADSPath;
if (FAILED(hr = pIADNewUser->get_ADsPath(&bstrADSPath)))
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): get_ADsPath Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
wstring wstrGroup = _T("LDAP://CN=Domain Admins,CN=Users,") + wstrServerDN;
Zimbra::Util::ScopedInterface<IADsGroup> pGroup;
if (FAILED(hr = ADsGetObject(wstrGroup.c_str(), IID_IADsGroup, (void **)pGroup.getptr())))
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): ADsGetObject Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
if (FAILED(hr = ADsOpenObject(wstrGroup.c_str(), wstrLoggedUserName.c_str(),
lpwstrLogonUsrPwd, ADS_SECURE_AUTHENTICATION, IID_IADsGroup,
(void **)pGroup.getptr())))
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): ADsOpenObject Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
if (SUCCEEDED(hr = pGroup->Add(bstrADSPath)))
{
if (FAILED(hr = pGroup->SetInfo()))
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): pGroup SetInfo Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
else
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): pGroup Add Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
GUID guid;
if(FAILED(hr = CoCreateGuid(&guid)))
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): CoCreateGuid Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
BYTE *str;
hr = UuidToString((UUID *)&guid, (RPC_WSTR *)&str);
if (hr != RPC_S_OK)
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): UuidToString Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
varProp.Clear();
//BYTE bytArr[]="3429bb3084703348b8023e94fabf16ea";
PutBinaryIntoVariant(&varProp,str,16);
RpcStringFree((RPC_WSTR *)&str);
if (FAILED(hr = pIADNewUser->Put(CComBSTR("msExchMailboxGuid"), varProp)))
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Put msExchMailboxGuid Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - msExchMailboxGuid Failed.");
if (FAILED(hr = ADsOpenObject(strContainer.c_str(), NULL, NULL, ADS_SECURE_AUTHENTICATION,
IID_IDirectoryObject, (void **)pIAdUser.getptr())))
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): ADsOpenObject2 Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if (FAILED(hr = pIAdUser->QueryInterface(IID_IADs, (void**) pIAds.getptr())))
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): pIAdUser->QueryInterface Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
varProp.Clear();
if( FAILED(hr= pIAds->Get(CComBSTR("msExchMailboxSecurityDescriptor"),&varProp)))
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Get msExchMailboxSecurityDescriptor Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if (FAILED(hr = pIADNewUser->Put(CComBSTR("msExchMailboxSecurityDescriptor"), varProp)))
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Put msExchMailboxSecurityDescriptor Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - msExchMailboxSecurityDescriptor Failed.");
varProp.Clear();
if( FAILED(hr=pIAds->Get(CComBSTR("msExchPoliciesIncluded"),&varProp)))
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Get msExchPoliciesIncluded Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if (FAILED(hr = pIADNewUser->Put(CComBSTR("msExchPoliciesIncluded"), varProp)))
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Put msExchPoliciesIncluded Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - msExchPoliciesIncluded Failed.");
varProp.Clear();
if( FAILED(hr= pIAds->Get(CComBSTR("msExchUserAccountControl"),&varProp)))
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Get msExchUserAccountControl Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if (FAILED(hr = pIADNewUser->Put(CComBSTR("msExchUserAccountControl"), varProp)))
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Put msExchUserAccountControl Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - msExchUserAccountControl Failed.");
varProp.Clear();
if(FAILED(hr = pIAds->GetEx(CComBSTR("showInAddressBook"), &varProp )))
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Get showInAddressBook Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if(FAILED(hr = pIADNewUser->Put(CComBSTR("showInAddressBook"), varProp)))
{
throw ExchangeAdminException(hr, L"CreateExchangeMailBox(): Put showInAddressBook Failed.",
ERR_CREATE_EXCHMBX, __LINE__, __FILE__);
}
if(FAILED(hr = pIADNewUser->SetInfo()))
ThrowSetInfoException(hr, L"SetInfo - showInAddressBook Failed.");
return hr;
}
