HRESULT CUIElement::GetName(BSTR* pbstrName)
{
DEBUG_ASSERT(pbstrName) ;
IF_RETURN(NULL == pbstrName, E_INVALIDARG) ;
CComBSTR bstrName(this->m_cstrElementName) ;
return bstrName.CopyTo(pbstrName) ;
}
/**
* @interface_method_impl{PDMIPCIRAWUP,pfnPciDeviceConstructComplete}
*/
DECLCALLBACK(int) PCIRawDev::drvDeviceConstructComplete(PPDMIPCIRAWCONNECTOR pInterface, const char *pcszName,
uint32_t uHostPCIAddress, uint32_t uGuestPCIAddress,
int rc)
{
PDRVMAINPCIRAWDEV pThis = RT_FROM_CPP_MEMBER(pInterface, DRVMAINPCIRAWDEV, IConnector);
Console *pConsole = pThis->pPCIRawDev->getParent();
const ComPtr<IMachine>& machine = pConsole->machine();
ComPtr<IVirtualBox> vbox;
HRESULT hrc = machine->COMGETTER(Parent)(vbox.asOutParam());
Assert(SUCCEEDED(hrc));
ComPtr<IEventSource> es;
hrc = vbox->COMGETTER(EventSource)(es.asOutParam());
Assert(SUCCEEDED(hrc));
Bstr bstrId;
hrc = machine->COMGETTER(Id)(bstrId.asOutParam());
Assert(SUCCEEDED(hrc));
ComObjPtr<PCIDeviceAttachment> pda;
BstrFmt bstrName(pcszName);
pda.createObject();
pda->init(machine, bstrName, uHostPCIAddress, uGuestPCIAddress, TRUE);
Bstr msg("");
if (RT_FAILURE(rc))
msg = BstrFmt("runtime error %Rrc", rc);
fireHostPCIDevicePlugEvent(es, bstrId.raw(), true /* plugged */, RT_SUCCESS(rc) /* success */, pda, msg.raw());
return VINF_SUCCESS;
}
HRESULT GetElementById(const CString& cszId, CComPtr<IHTMLElement>& spElement)
{
CComPtr<IHTMLDocument2> spIHTMLDocument2;
HRESULT hr = GetHtmlDocument(spIHTMLDocument2);
if (FAILED(hr))
return hr;
CComPtr<IHTMLElementCollection> spIHTMLElementCollection;
hr = spIHTMLDocument2->get_all(&spIHTMLElementCollection);
if (FAILED(hr))
return hr;
CComBSTR bstrName(cszId);
CComVariant varName(bstrName);
CComVariant varIndex(static_cast<int>(0));
CComPtr<IDispatch> spIDispatchIHTMLElement;
hr = spIHTMLElementCollection->item(varName, varIndex, &spIDispatchIHTMLElement);
if (FAILED(hr))
return hr;
if (spIDispatchIHTMLElement == NULL)
return E_FAIL;
return spIDispatchIHTMLElement.QueryInterface<IHTMLElement>(&spElement);
}
void CTangramExcelPlusWB::OnSheetActivate(IDispatch* Sh)
{
CComQIPtr<Excel::_Worksheet> pSheet(Sh);
if(pSheet)
{
CComBSTR bstrName(L"");
pSheet->get_Name(&bstrName);
CString strName = OLE2T(bstrName);
CTangramXmlParse* pParse2 = GetChild(strName);
if(pParse2==NULL)
pParse2 = GetChild(_T("Default"));
if(pParse2)
{
HWND hWnd = ::GetActiveWindow();
HWND m_hClientWnd = ::FindWindowEx(hWnd,NULL,_T("XLDESK"),NULL);
HWND m_hWorkBookWnd = (HWND) ::SendMessage(m_hClientWnd,WM_MDIGETACTIVE,0,0);
CTangramExcelPlusWBWnd* pExcelWorkBookWnd = (CTangramExcelPlusWBWnd*)::SendMessage(m_hWorkBookWnd,WM_TANGRAMDATA,0,0);
pExcelWorkBookWnd->m_strActiveSheetName = strName;
CComPtr<ITangramNode> pNode;
pExcelWorkBookWnd->m_pWorkBook->m_pFrame->Extend(bstrName, CComBSTR(pParse2->xml()), &pNode);
// if(theApp.m_bOldVer)
// {
// if(pExcelWorkBookWnd&&pExcelWorkBookWnd->m_pWorkBook->m_pFrame)
// {
//pExcelWorkBookWnd->m_pWorkBook->m_pFrame->ModifyHost((LONGLONG)pExcelWorkBookWnd->m_pHeplerWnd->m_hWnd,(LONGLONG)pExcelWorkBookWnd->m_pHeplerWnd->m_pChild->m_hWnd);
// theApp.m_pTangramCore->NavigateXTML((LONGLONG)pExcelWorkBookWnd->m_pHeplerWnd->m_pChild->m_hWnd,CComBSTR(pParse2->xml()),&pNode);
//pExcelWorkBookWnd->m_pWorkBook->m_pFrame->ModifyHost((LONGLONG)hWnd,(LONGLONG)m_hClientWnd);
// }
// }
// else
// theApp.m_pTangramManager->NavigateXTML((LONGLONG)m_hClientWnd,CComBSTR(pParse2->xml()),&pNode);
}
}
}
HRESULT MachineDebugger::getOSName(com::Utf8Str &aOSName)
{
LogFlowThisFunc(("\n"));
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
Console::SafeVMPtr ptrVM(mParent);
HRESULT hrc = ptrVM.rc();
if (SUCCEEDED(hrc))
{
/*
* Do the job and try convert the name.
*/
char szName[64];
int vrc = DBGFR3OSQueryNameAndVersion(ptrVM.rawUVM(), szName, sizeof(szName), NULL, 0);
if (RT_SUCCESS(vrc))
{
try
{
Bstr bstrName(szName);
aOSName = Utf8Str(bstrName);
}
catch (std::bad_alloc)
{
hrc = E_OUTOFMEMORY;
}
}
else
hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSQueryNameAndVersion failed with %Rrc"), vrc);
}
return hrc;
}
HRESULT XPCDispObject::COMCreateInstance(XPCCallContext & ccx, BSTR className,
PRBool enforceSecurity,
IDispatch ** result)
{
NS_ENSURE_ARG_POINTER(result);
// Turn the string into a CLSID
_bstr_t bstrName(className);
CLSID classID = CLSID_NULL;
HRESULT hr = CLSIDFromString(bstrName, &classID);
if(FAILED(hr))
hr = CLSIDFromProgID(bstrName, &classID);
if(FAILED(hr) || ::IsEqualCLSID(classID, CLSID_NULL))
return hr;
// If the caller cares about security do the necessary checks
// This results in the object being instantiated, so we'll use
// it
if(enforceSecurity)
return SecurityCheck(ccx, classID, result);
CComPtr<IDispatch> disp;
#ifdef JAXER
hr = disp.CoCreateInstance(classID, NULL, CLSCTX_SERVER);
#else
hr = disp.CoCreateInstance(classID);
#endif /* JAXER */
if(FAILED(hr))
return hr;
disp.CopyTo(result);
return S_OK;
}
/// \see http://stackoverflow.com/questions/324974/in-wia-how-can-i-add-my-program-in-the-program-list-of-acquiring-images-from-a
void App::RegisterWIAHandler(bool bRegister)
{
CComPtr<IWiaDevMgr> spWiaDevMgr;
HRESULT hr = spWiaDevMgr.CoCreateInstance(CLSID_WiaDevMgr,
NULL,
CLSCTX_LOCAL_SERVER);
if (FAILED(hr))
return;
CComBSTR bstrCommandline(_T("\"") + Path::ModuleFilename() + _T("\" --open-wia \"%1\" \"%2\""));
CComBSTR bstrName(CString(MAKEINTRESOURCE(IDR_MAINFRAME)));
CComBSTR bstrDescription(CString(MAKEINTRESOURCE(IDR_WIA_DESC)));
CComBSTR bstrIcon(Path::ModuleFilename() + _T(",0"));
hr = spWiaDevMgr->RegisterEventCallbackProgram(
bRegister ? WIA_REGISTER_EVENT_CALLBACK : WIA_UNREGISTER_EVENT_CALLBACK,
NULL,
&WIA_EVENT_DEVICE_CONNECTED,
bstrCommandline,
bstrName,
bstrDescription,
bstrIcon);
// when this fails, the user isn't an elevated user
if (FAILED(hr))
AtlMessageBox(NULL, _T("Error registering/unregisterin WIA event! Are you administrator?"), IDR_MAINFRAME, MB_OK);
}
/*! Provides deck name
// \param BSTR *pVal :
*/
STDMETHODIMP CAxJpgCard::get_DeckName(BSTR *pVal)
{
if (pVal)
{
CComBSTR bstrName("Piacentine");
*pVal = (BSTR)bstrName;
}
return S_OK;
}
long CXmlManager::GetSubNodeNumber( IXMLDOMNode* lpNode, LPCTSTR lpNodesName )
{
CComPtr<IXMLDOMNodeList> lpItemNewList;
CComBSTR bstrName(lpNodesName);
long iLength = 0;
if ( !SUCCEEDED(lpNode->selectNodes( bstrName, &lpItemNewList) ) )
return iLength;
lpItemNewList->get_length(&iLength);
return iLength;
}
STDMETHODIMP CVectorObject::Terminate()
{
#ifdef _DEBUG
CComBSTR bstrName("n/a");
if (m_pParent)
{
m_pParent->get_Name(&bstrName.m_str);
VWTRACE(m_pWorld, "VWOBJECT", TRACE_ALLOCATION, "CVectorObject::Terminate, %s.%s, this 0x%0x\n", CString(bstrName), CString(m_bstrPropertyName), this);
}
#endif
CVectorObjectBase::Terminate();
return S_OK;
}
/*
Function name : CXML::CreateAttributeNode
Description :
Return type : bool
Argument : IXMLDOMNode **pParentNode
Argument : CString csAttribute
Argument : CString csValue
Tested : Ok
*/
bool CXML::CreateAttributeNode(IXMLDOMNode **pParentNode,CString csAttribute,CString csValue)
{
IXMLDOMNode * pNode = NULL;
if(csAttribute.IsEmpty())
return false;
if(!(*pParentNode))
return false;
_variant_t vtNodeType((long)NODE_ATTRIBUTE);
_bstr_t bstrName(csAttribute);
_bstr_t bstrNameSpace("");
m_hr = m_pXMLDoc->createNode(vtNodeType,bstrName,bstrNameSpace,&pNode);
if(!SUCCEEDED(m_hr))
return false;
IXMLDOMNamedNodeMap * pAttributes = NULL;
m_hr = (*pParentNode)->get_attributes(&pAttributes);
if(!SUCCEEDED(m_hr) || !pAttributes)
{
pNode->Release();
return false;
}
IXMLDOMNode *pNewNode = NULL;
m_hr = pAttributes->setNamedItem(pNode,&pNewNode);
pNode->Release();
pAttributes->Release();
if(!SUCCEEDED(m_hr) || !pNewNode)
return false;
_variant_t vtValue(csValue);
m_hr = pNewNode->put_nodeValue(vtValue);
pNewNode->Release();
if(!SUCCEEDED(m_hr) || !pNewNode)
return false;
return true;
}
/*******************************************************************************
Function Name : DefineUpdateWave
Input(s) : -
Output : -
Functionality : This function defines waveform and updates existing.
Member of : CWaveformSelectionDlg
Friend of : -
Author(s) : K ArunKumar
Date Created : 24.08.2010
Modification By :
Modification on :
*******************************************************************************/
void CWaveformSelectionDlg::DefineUpdateWave(CListCtrl* pListCtrl, UINT nMsgID,
CString strSignalName, sWaveformInfo& objWaveInfo)
{
if (pListCtrl->GetSelectionMark() != -1)
{
CString strSignalDetails;
strSignalDetails.Format(_T("0x%x->%s"), nMsgID, strSignalName);
//BSTR bstrName = (BSTR)strSignalDetails.GetBuffer(MAX_PATH);
BSTR bstrName(L"");
SignalDefiner_SetSignalDetails(bstrName);
SignalDefiner_SetType((SIGNAL_TYPE)objWaveInfo.m_eSignalWaveType);
SignalDefiner_SetAmplitude(objWaveInfo.m_fAmplitude);
SignalDefiner_SetFrequency(objWaveInfo.m_fFrequency);
SignalDefiner_SetSamplingTimePeriod(m_pWaveDataHandler->shGetSamplingTimePeriod());
if ( SignalDefiner_ShowDlg() == IDOK )
{
SIGNAL_TYPE enSelSignalType;
SignalDefiner_GetType(&enSelSignalType);
objWaveInfo.m_eSignalWaveType = (eWAVEFORMTYPE)enSelSignalType;
SignalDefiner_GetAmplitude(&objWaveInfo.m_fAmplitude);
SignalDefiner_GetFrequency(&objWaveInfo.m_fFrequency);
if(pListCtrl == &m_omListCtrlSignal)
{
m_pWaveDataHandler->bAddSignalToDefinedWavesList(nMsgID, strSignalName, objWaveInfo);
}
else
{
m_pWaveDataHandler->vSetSignalWavePatternDetails(nMsgID, strSignalName, objWaveInfo);
}
// Force a setting of sampling time period.typecast to remove compiler warning
int nTimePeriod;
SignalDefiner_GetSamplingTimePeriod(&nTimePeriod);
m_pWaveDataHandler->vSetSamplingTimePeriod(nTimePeriod);
}
//Free the BSTR memory allocated
::SysFreeString(bstrName);
}
}
/**
* Handles the info sub-command.
*
* @returns Suitable exit code.
* @param pArgs The handler arguments.
* @param pDebugger Pointer to the debugger interface.
*/
static RTEXITCODE handleDebugVM_Info(HandlerArg *pArgs, IMachineDebugger *pDebugger)
{
/*
* Parse arguments.
*/
const char *pszInfo = NULL;
const char *pszArgs = NULL;
RTGETOPTSTATE GetState;
RTGETOPTUNION ValueUnion;
int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, NULL, 0, 2, RTGETOPTINIT_FLAGS_OPTS_FIRST);
AssertRCReturn(rc, RTEXITCODE_FAILURE);
while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
{
switch (rc)
{
case VINF_GETOPT_NOT_OPTION:
if (!pszInfo)
pszInfo = ValueUnion.psz;
else if (!pszArgs)
pszArgs = ValueUnion.psz;
else
return errorTooManyParameters(&pArgs->argv[GetState.iNext - 1]);
break;
default:
return errorGetOpt(rc, &ValueUnion);
}
}
if (!pszInfo)
return errorSyntax("Must specify info item to display");
/*
* Do the work.
*/
com::Bstr bstrName(pszInfo);
com::Bstr bstrArgs(pszArgs);
com::Bstr bstrInfo;
CHECK_ERROR2I_RET(pDebugger, Info(bstrName.raw(), bstrArgs.raw(), bstrInfo.asOutParam()), RTEXITCODE_FAILURE);
RTPrintf("%ls", bstrInfo.raw());
return RTEXITCODE_SUCCESS;
}
// 设置属性值
int CBpXMLNode::SetAttribute(const wchar_t *szAttrName, const wchar_t *szAttrValue)
{
if (m_pDOMNode == NULL || szAttrName == NULL || szAttrValue == NULL)
return XML_ERROR;
if (m_pDOMNode->GetnodeType() != MSXML2::NODE_ELEMENT)
return XML_ERROR;
try
{
_bstr_t bstrName(szAttrName);
MSXML2::IXMLDOMElementPtr pElemt = (MSXML2::IXMLDOMElementPtr)m_pDOMNode;
pElemt->setAttribute(_bstr_t(szAttrName),_variant_t(szAttrValue));
}
catch (...)
{
return XML_ERROR;
}
return XML_OK;
}
STDMETHODIMP CCoAutoRun::GetNativeLanguageName(
__in int LocaleId, __deref_out BSTR* Name)
{
TCHAR buffer[250] = {0};
int n = GetLocaleInfo(
static_cast<LCID>(LocaleId),
LOCALE_SNATIVELANGNAME,
buffer,
RTL_NUMBER_OF(buffer));
if (0 == n)
{
return HRESULT_FROM_WIN32(GetLastError());
}
CComBSTR bstrName(buffer);
*Name = bstrName.Detach();
return S_OK;
}
HRESULT CBasePropSetter::FindVal(const TCHAR* szName, BSTR *pbstrVal)
{
CComBSTR bstrName(szName);
deque<CComBSTR>::iterator prop_iter, val_iter;
val_iter = value_list.begin();
for (prop_iter = prop_list.begin();
prop_iter != prop_list.end();
++prop_iter, ++val_iter)
{
if ((*prop_iter) == bstrName)
{
*pbstrVal = (*val_iter).Copy();
return S_OK;
}
}
*pbstrVal = 0;
return E_FAIL;
}
STDMETHODIMP MachineDebugger::COMGETTER(OSName)(BSTR *a_pbstrName)
{
LogFlowThisFunc(("\n"));
CheckComArgNotNull(a_pbstrName);
AutoCaller autoCaller(this);
HRESULT hrc = autoCaller.rc();
if (SUCCEEDED(hrc))
{
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
Console::SafeVMPtr ptrVM(mParent);
hrc = ptrVM.rc();
if (SUCCEEDED(hrc))
{
/*
* Do the job and try convert the name.
*/
char szName[64];
int vrc = DBGFR3OSQueryNameAndVersion(ptrVM.raw(), szName, sizeof(szName), NULL, 0);
if (RT_SUCCESS(vrc))
{
try
{
Bstr bstrName(szName);
bstrName.detachTo(a_pbstrName);
}
catch (std::bad_alloc)
{
hrc = E_OUTOFMEMORY;
}
}
else
hrc = setError(VBOX_E_VM_ERROR, tr("DBGFR3OSQueryNameAndVersion failed with %Rrc"), vrc);
}
}
return hrc;
}
/**
* Handles the setregisters sub-command.
*
* @returns Suitable exit code.
* @param pArgs The handler arguments.
* @param pDebugger Pointer to the debugger interface.
*/
static RTEXITCODE handleDebugVM_SetRegisters(HandlerArg *pArgs, IMachineDebugger *pDebugger)
{
/*
* We take a list of register assignments, that is register=value.
*/
ULONG idCpu = 0;
com::SafeArray<IN_BSTR> aBstrNames;
com::SafeArray<IN_BSTR> aBstrValues;
RTGETOPTSTATE GetState;
RTGETOPTUNION ValueUnion;
static const RTGETOPTDEF s_aOptions[] =
{
{ "--cpu", 'c', RTGETOPT_REQ_UINT32 },
};
int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, RTGETOPTINIT_FLAGS_OPTS_FIRST);
AssertRCReturn(rc, RTEXITCODE_FAILURE);
while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
{
switch (rc)
{
case 'c':
idCpu = ValueUnion.u32;
break;
case VINF_GETOPT_NOT_OPTION:
{
const char *pszEqual = strchr(ValueUnion.psz, '=');
if (!pszEqual)
return errorSyntax("setregisters expects input on the form 'register=value' got '%s'", ValueUnion.psz);
try
{
com::Bstr bstrName(ValueUnion.psz, pszEqual - ValueUnion.psz);
com::Bstr bstrValue(pszEqual + 1);
if ( !aBstrNames.push_back(bstrName.raw())
|| !aBstrValues.push_back(bstrValue.raw()))
throw std::bad_alloc();
}
catch (std::bad_alloc)
{
RTMsgError("Out of memory\n");
return RTEXITCODE_FAILURE;
}
break;
}
default:
return errorGetOpt(rc, &ValueUnion);
}
}
if (!aBstrNames.size())
return errorSyntax("The setregisters sub-command takes at least one register name");
/*
* If it is only one register, use the single register method just so
* we expose it and can test it from the command line.
*/
if (aBstrNames.size() == 1)
{
CHECK_ERROR2I_RET(pDebugger, SetRegister(idCpu, aBstrNames[0], aBstrValues[0]), RTEXITCODE_FAILURE);
RTPrintf("Successfully set %ls\n", aBstrNames[0]);
}
else
{
CHECK_ERROR2I_RET(pDebugger, SetRegisters(idCpu, ComSafeArrayAsInParam(aBstrNames), ComSafeArrayAsInParam(aBstrValues)),
RTEXITCODE_FAILURE);
RTPrintf("Successfully set %u registers\n", aBstrNames.size());
}
return RTEXITCODE_SUCCESS;
}
stdex::tString CSystemInfo::GetWmiInfo( LPCTSTR lpszQuery, LPCTSTR lpszField )
{
CComPtr<IWbemLocator> pIWbemLocator;
CComPtr<IWbemServices> pWbemServices;
stdex::tString strValue;
HRESULT hr = CoInitialize(NULL);
hr = CoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_PKT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, 0);
if (hr != S_OK && hr != RPC_E_TOO_LATE)
{
CoUninitialize();
return strValue;
}
if(CoCreateInstance (CLSID_WbemAdministrativeLocator, NULL, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER, \
IID_IUnknown , reinterpret_cast<void**>(&pIWbemLocator.p)) == S_OK)
{
if (pIWbemLocator->ConnectServer(BSTR(L"root\\cimv2"), \
NULL, NULL, NULL, 0, NULL, NULL, &pWbemServices.p) == S_OK)
{
CComPtr<IEnumWbemClassObject> pEnumObject;
hr = pWbemServices->ExecQuery(_bstr_t("WQL"), _bstr_t(lpszQuery),WBEM_FLAG_RETURN_IMMEDIATELY,NULL,&pEnumObject.p);
if(FAILED(hr))
{
CoUninitialize();
return strValue;
}
hr = pEnumObject->Reset();
if(FAILED(hr))
{
CoUninitialize();
return strValue;
}
CComPtr<IWbemClassObject> pClassObject;
ULONG uCount = 1, uReturned = 0;
hr = pEnumObject->Next(C_WAIT_WMI_TIME, uCount, &pClassObject.p, &uReturned);
if (SUCCEEDED(hr) && pClassObject != NULL)
{
do
{
assert(pClassObject != NULL);
CComVariant varValue ;
_bstr_t bstrName(lpszField);
if( pClassObject->Get( bstrName ,0 ,&varValue ,NULL ,0 ) == S_OK )
{
if(varValue.vt == VT_NULL || varValue.vt == VT_EMPTY || varValue.vt == VT_ERROR)
break;
_bstr_t b;
if( varValue.vt & VT_BSTR )
{
b = &varValue;
strValue = stdex::tString(b);
}
else if( varValue.vt & VT_ARRAY )
{
long iLowBound = 0 , iUpBound = 0 ;
SafeArrayGetLBound( varValue.parray , 1 , &iLowBound ) ;
SafeArrayGetUBound( varValue.parray , 1 , &iUpBound ) ;
for( long j = iLowBound ; j <= iUpBound ; j ++ )
{
VARIANT *pvar = NULL ;
long temp = j ;
if( SafeArrayGetElement( varValue.parray , &temp , pvar ) == S_OK &&
pvar )
{
CComVariant varTemp ;
if( varTemp.ChangeType( VT_BSTR , pvar ) == S_OK )
{
if(!strValue.empty())
strValue += TEXT(",");
b = &varTemp;
strValue += stdex::tString(b) ;
}
}
}
}
else
{
if( varValue.ChangeType( VT_BSTR ) == S_OK )
{
b = &varValue;
strValue += stdex::tString(b) ;
}
}
}
} while (FALSE);
}
}
}
CoUninitialize();
return strValue;
}
/*
Function name : CXML::CreateElement
Description : This function create an element node set it as the current Node
: with attributes and value and the text supplied
Return type : bool
Argument : IXMLDOMNode **ppRemoveNode
*/
bool CXML::CreateElement(CString csTagName,LPCTSTR lpszText,char ** ppAttributes,char ** ppValues,int nNoOfAttributes,bool bSetAsCurNode)
{
IXMLDOMNode * pNode = NULL;
if(csTagName.IsEmpty())
return false;
if(!m_pICurrentNode)
return false;
_variant_t vtNodeType((long)NODE_ELEMENT);
_bstr_t bstrName(csTagName);
_bstr_t bstrNameSpace("");
m_hr = m_pXMLDoc->createNode(vtNodeType,bstrName,bstrNameSpace,&pNode);
if(!SUCCEEDED(m_hr))
return false;
if(m_pINewElement)
{
m_pINewElement->Release();
m_pINewElement = NULL;
}
if(!AddNode(&m_pICurrentNode,&pNode,&m_pINewElement,NODE_ELEMENT))
{
pNode->Release();
return false;
}
if(!m_pINewElement)
return false;
if(lpszText)
{
_bstr_t bstrData(lpszText);
m_hr = pNode->put_text(bstrData);
if(!SUCCEEDED(m_hr))
{
pNode->Release();
return false;
}
}
pNode->Release();
if(nNoOfAttributes && ppAttributes && ppValues )
{
for(int i = 0;i<nNoOfAttributes;++i)
{
if(!CreateAttributeNode(&m_pINewElement,ppAttributes[i],ppValues[i]))
return false;
}
}
if(bSetAsCurNode)
{
if(m_pICurrentNode)
{
m_pICurrentNode->Release();
m_pICurrentNode = NULL;
}
m_pICurrentNode = m_pINewElement;
m_pICurrentNode->AddRef();
}
return true;
}
//begin CTangramOutLookPlusNavigationPaneEvents_12:
void CTangramOutLookPlusExplorer::OnModuleSwitch(NavigationModule* pCurrentModule)
{
CComQIPtr<_NavigationModule> _pNavigationModule((_NavigationModule*)pCurrentModule);
if (m_pNavigationGroups)
{
HRESULT hr = ((CTangramOutLookPlusNavigationGroupsEvents_12*)this)->DispEventUnadvise(m_pNavigationGroups);
m_pNavigationGroups->Release();
m_pNavigationGroups = NULL;
m_pCurrentModule->Release();
m_pCurrentModule = _pNavigationModule.p;
m_pCurrentModule->AddRef();
}
if (_pNavigationModule)
{
HRESULT hr = _pNavigationModule->get_NavigationModuleType(&m_nNType);
CComBSTR bstrName("");
switch (m_nNType)
{
case olModuleMail:
{
CComQIPtr<_MailModule> _pModule(m_pCurrentModule);
if (_pModule)
_pModule->get_NavigationGroups(&m_pNavigationGroups);
}
break;
case olModuleCalendar:
{
CComQIPtr<_CalendarModule> _pModule(m_pCurrentModule);
if (_pModule)
_pModule->get_NavigationGroups(&m_pNavigationGroups);
}
break;
case olModuleContacts:
{
CComQIPtr<_ContactsModule> _pModule(m_pCurrentModule);
if (_pModule)
_pModule->get_NavigationGroups(&m_pNavigationGroups);
}
break;
case olModuleTasks:
{
CComQIPtr<_TasksModule> _pModule(m_pCurrentModule);
if (_pModule)
_pModule->get_NavigationGroups(&m_pNavigationGroups);
}
break;
case olModuleJournal:
{
CComQIPtr<_JournalModule> _pModule(m_pCurrentModule);
if (_pModule)
_pModule->get_NavigationGroups(&m_pNavigationGroups);
}
break;
case olModuleNotes:
{
CComQIPtr<_NotesModule> _pModule(m_pCurrentModule);
if (_pModule)
_pModule->get_NavigationGroups(&m_pNavigationGroups);
}
break;
case olModuleFolderList:
case olModuleShortcuts:
case olModuleSolutions:
break;
}
if (m_nNType == olModuleSolutions)
{
//if (::IsChild(m_hWnd, theApp.m_pSolutionHelperWnd->m_hWnd) == false)
//{
// ::SetParent(theApp.m_pSolutionHelperWnd->m_hWnd, m_hWnd);
// theApp.m_pSolutionFrame->ModifyHost((LONGLONG)m_pTangramSolutionHostWnd->m_hWnd, (LONGLONG)m_hNavWnd);
//}
//if (m_hNavWnd&&theApp.m_pSolutionFrame)
//{
// if (theApp.m_pSolutionHelperWnd&&::IsWindow(theApp.m_pSolutionHelperWnd->m_hWnd))
// ::ShowWindow(theApp.m_pSolutionHelperWnd->m_hWnd, SW_SHOW);
// if (m_hButton)
// ::ShowWindow(m_hButton, SW_HIDE);
// theApp.m_pSolutionFrame->Attach();
//}
}
else
{
//if (m_hNavWnd&&theApp.m_pSolutionFrame)
//{
// if (theApp.m_pSolutionHelperWnd&&::IsWindow(theApp.m_pSolutionHelperWnd->m_hWnd))
// ::ShowWindow(theApp.m_pSolutionHelperWnd->m_hWnd, SW_HIDE);
// if (m_hButton)
// ::ShowWindow(m_hButton, SW_SHOW);
// theApp.m_pSolutionFrame->Deatch();
//}
}
if (m_pNavigationGroups)
{
m_pNavigationGroups->AddRef();
hr = ((CTangramOutLookPlusNavigationGroupsEvents_12*)this)->DispEventAdvise(m_pNavigationGroups);
}
}
}
