//------------------------------------------------------------------------//
BOOL CBCGPGlobalUtils::DecimalFromString(DECIMAL& decimal, LPCTSTR psz)
{
USES_CONVERSION;
if (psz == NULL || _tcslen (psz) == 0)
{
psz = _T("0");
}
VARIANTARG varBstr;
VARIANTARG varDecimal;
AfxVariantInit(&varBstr);
AfxVariantInit(&varDecimal);
V_VT(&varBstr) = VT_BSTR;
V_BSTR(&varBstr) = SysAllocString(T2COLE(psz));
if (FAILED(VariantChangeType(&varDecimal, &varBstr, 0, VT_DECIMAL)))
{
VariantClear(&varBstr);
VariantClear(&varDecimal);
return FALSE;
}
decimal = V_DECIMAL(&varDecimal);
VariantClear(&varBstr);
VariantClear(&varDecimal);
return TRUE;
}
//------------------------------------------------------------------------//
BOOL CBCGPGlobalUtils::CyFromString(CY& cy, LPCTSTR psz)
{
USES_CONVERSION;
if (psz == NULL || _tcslen (psz) == 0)
{
psz = _T("0");
}
VARIANTARG varBstr;
VARIANTARG varCy;
AfxVariantInit(&varBstr);
AfxVariantInit(&varCy);
V_VT(&varBstr) = VT_BSTR;
V_BSTR(&varBstr) = SysAllocString(T2COLE(psz));
if (FAILED(VariantChangeType(&varCy, &varBstr, 0, VT_CY)))
{
VariantClear(&varBstr);
VariantClear(&varCy);
return FALSE;
}
cy = V_CY(&varCy);
VariantClear(&varBstr);
VariantClear(&varCy);
return TRUE;
}
COleVariant::COleVariant(LPCITEMIDLIST pidl)
{
AfxVariantInit(this);
if (pidl != NULL)
{
// walk through entries in the list and accumulate their size
UINT cbTotal = 0;
SAFEARRAY *psa = NULL;
LPCITEMIDLIST pidlWalker = pidl;
while (pidlWalker->mkid.cb)
{
cbTotal += pidlWalker->mkid.cb;
pidlWalker = (LPCITEMIDLIST)
(((LPBYTE)pidlWalker) + pidlWalker->mkid.cb);
}
// add the base structure size
cbTotal += sizeof(ITEMIDLIST);
// get a safe array for them
psa = SafeArrayCreateVector(VT_UI1, 0, cbTotal);
// copy it and set members
if (psa != NULL)
{
memcpy(psa->pvData, (LPBYTE) pidl, cbTotal);
vt = VT_ARRAY | VT_UI1;
parray = psa;
}
}
}
BOOL _AfxStringFromCy(CString& str, CY& cy)
{
VARIANTARG varCy;
VARIANTARG varBstr;
AfxVariantInit(&varCy);
AfxVariantInit(&varBstr);
V_VT(&varCy) = VT_CY;
V_CY(&varCy) = cy;
if (FAILED(VariantChangeType(&varBstr, &varCy, 0, VT_BSTR)))
{
VariantClear(&varCy);
VariantClear(&varBstr);
return FALSE;
}
str = V_BSTR(&varBstr);
VariantClear(&varCy);
VariantClear(&varBstr);
return TRUE;
}
//------------------------------------------------------------------------//
BOOL CBCGPGlobalUtils::StringFromDecimal(CString& str, DECIMAL& decimal)
{
VARIANTARG varDecimal;
VARIANTARG varBstr;
AfxVariantInit(&varDecimal);
AfxVariantInit(&varBstr);
V_VT(&varDecimal) = VT_DECIMAL;
V_DECIMAL(&varDecimal) = decimal;
if (FAILED(VariantChangeType(&varBstr, &varDecimal, 0, VT_BSTR)))
{
VariantClear(&varDecimal);
VariantClear(&varBstr);
return FALSE;
}
str = V_BSTR(&varBstr);
VariantClear(&varDecimal);
VariantClear(&varBstr);
return TRUE;
}
BOOL _AfxCyFromString(CY& cy, LPCTSTR psz)
{
USES_CONVERSION;
VARIANTARG varBstr;
VARIANTARG varCy;
AfxVariantInit(&varBstr);
AfxVariantInit(&varCy);
V_VT(&varBstr) = VT_BSTR;
V_BSTR(&varBstr) = SysAllocString(T2COLE(psz));
if (FAILED(VariantChangeType(&varCy, &varBstr, 0, VT_CY)))
{
VariantClear(&varBstr);
VariantClear(&varCy);
return FALSE;
}
cy = V_CY(&varCy);
VariantClear(&varBstr);
VariantClear(&varCy);
return TRUE;
}
SCODE CCmdTarget::SetStandardProp(const AFX_DISPMAP_ENTRY* pEntry,
DISPPARAMS* pDispParams, UINT* puArgErr)
{
ASSERT(pEntry != NULL);
ASSERT(*puArgErr != 0);
// it is a DISPATCH_PROPERTYSET (for standard, non-function property)
SCODE sc = S_OK;
VARIANT va;
AfxVariantInit(&va);
VARIANT* pArg = &pDispParams->rgvarg[0];
if (pEntry->vt != VT_VARIANT && pArg->vt != pEntry->vt)
{
// argument is not of appropriate type, attempt to coerce it
sc = VariantChangeType(&va, pArg, 0, pEntry->vt);
if (FAILED(sc))
{
TRACE0("Warning: automation property coercion failed.\n");
*puArgErr = 0;
return sc;
}
ASSERT(va.vt == pEntry->vt);
pArg = &va;
}
void* pProp = (BYTE*)this + pEntry->nPropOffset;
switch (pEntry->vt)
{
case VT_I1:
*(BYTE*)pProp = pArg->bVal;
break;
case VT_I2:
*(short*)pProp = pArg->iVal;
break;
case VT_I4:
*(long*)pProp = pArg->lVal;
break;
case VT_R4:
*(float*)pProp = pArg->fltVal;
break;
case VT_R8:
*(double*)pProp = pArg->dblVal;
break;
case VT_DATE:
*(double*)pProp = pArg->date;
break;
case VT_CY:
*(CY*)pProp = pArg->cyVal;
break;
case VT_BSTR:
AfxBSTR2CString((CString*)pProp, pArg->bstrVal);
break;
case VT_ERROR:
*(SCODE*)pProp = pArg->scode;
break;
case VT_BOOL:
*(BOOL*)pProp = (V_BOOL(pArg) != 0);
break;
case VT_VARIANT:
if (VariantCopy((LPVARIANT)pProp, pArg) != S_OK)
*puArgErr = 0;
break;
case VT_DISPATCH:
case VT_UNKNOWN:
if (pArg->punkVal != NULL)
pArg->punkVal->AddRef();
_AfxRelease((LPUNKNOWN*)pProp);
*(LPUNKNOWN*)pProp = pArg->punkVal;
break;
default:
*puArgErr = 0;
sc = DISP_E_BADVARTYPE;
}
VariantClear(&va);
// if property was a DISP_PROPERTY_NOTIFY type, call pfnSet after setting
if (!FAILED(sc) && pEntry->pfnSet != NULL)
{
AFX_MANAGE_STATE(m_pModuleState);
(this->*pEntry->pfnSet)();
}
return sc;
}
BOOL CCmdTarget::OnEvent(UINT idCtrl, AFX_EVENT* pEvent,
AFX_CMDHANDLERINFO* pHandlerInfo)
{
HRESULT hResult = S_OK;
UINT uArgError = (UINT)-1; // no error yet
const AFX_EVENTSINKMAP_ENTRY* pEntry = GetEventSinkEntry(idCtrl, pEvent);
// no handler for this event
if (pEntry == NULL)
return FALSE;
if (pHandlerInfo != NULL)
{
// just fill in the information, don't do it
pHandlerInfo->pTarget = this;
switch (pEvent->m_eventKind)
{
case AFX_EVENT::event:
case AFX_EVENT::propRequest:
pHandlerInfo->pmf = pEntry->dispEntry.pfn;
break;
case AFX_EVENT::propChanged:
pHandlerInfo->pmf = pEntry->dispEntry.pfnSet;
break;
default:
ASSERT(FALSE); // bogus value for pEvent->m_eventKind
}
return (pHandlerInfo->pmf != NULL);
}
BOOL bRange = (pEntry->nCtrlIDLast != (UINT)-1);
BOOL bHandled = FALSE;
TRY
{
switch (pEvent->m_eventKind)
{
case AFX_EVENT::event:
// do standard method call
VARIANT var;
AfxVariantInit(&var);
DISPPARAMS dispparams;
dispparams.rgvarg = NULL;
if (bRange)
{
memcpy(&dispparams, pEvent->m_pDispParams, sizeof(DISPPARAMS));
dispparams.rgvarg = new VARIANT[++dispparams.cArgs];
memcpy(dispparams.rgvarg, pEvent->m_pDispParams->rgvarg,
sizeof(VARIANT) * (dispparams.cArgs-1));
VARIANT* pvarID = &dispparams.rgvarg[dispparams.cArgs-1];
V_VT(pvarID) = VT_I4;
V_I4(pvarID) = idCtrl;
}
hResult = CallMemberFunc(&pEntry->dispEntry, DISPATCH_METHOD, &var,
(bRange ? &dispparams : pEvent->m_pDispParams), &uArgError);
ASSERT(FAILED(hResult) || (V_VT(&var) == VT_BOOL));
bHandled = V_BOOL(&var);
if (bRange)
delete [] dispparams.rgvarg;
break;
case AFX_EVENT::propChanged:
{
if (bRange)
{
PFN_CHANGED_RANGE pfn = (PFN_CHANGED_RANGE)pEntry->dispEntry.pfnSet;
bHandled = (this->*pfn)(idCtrl);
}
else
{
PFN_CHANGED pfn = (PFN_CHANGED)pEntry->dispEntry.pfnSet;
bHandled = (this->*pfn)();
}
hResult = S_OK;
}
break;
case AFX_EVENT::propRequest:
{
BOOL bAllow = TRUE;
if (bRange)
{
PFN_REQUEST_RANGE pfn = (PFN_REQUEST_RANGE)pEntry->dispEntry.pfn;
bHandled = (this->*pfn)(idCtrl, &bAllow);
}
else
{
PFN_REQUEST pfn = (PFN_REQUEST)pEntry->dispEntry.pfn;
bHandled = (this->*pfn)(&bAllow);
}
hResult = bAllow ? S_OK : S_FALSE;
}
break;
case AFX_EVENT::propDSCNotify:
{
BOOL bAllow = TRUE;
if (bRange)
{
PFN_DSCNOTIFY_RANGE pfn = (PFN_DSCNOTIFY_RANGE)pEntry->dispEntry.pfn;
bHandled = (this->*pfn)(idCtrl, pEvent->m_nDSCState,
pEvent->m_nDSCReason, &bAllow);
}
else
{
PFN_DSCNOTIFY pfn = (PFN_DSCNOTIFY)pEntry->dispEntry.pfn;
bHandled = (this->*pfn)(pEvent->m_nDSCState,
pEvent->m_nDSCReason, &bAllow);
}
hResult = bAllow ? S_OK : S_FALSE;
}
break;
default:
ASSERT(FALSE); // bogus value for pEvent->m_eventKind
}
}
CATCH_ALL(e)
{
if (pEvent->m_pExcepInfo != NULL)
{
// fill exception with translation of MFC exception
COleDispatchException::Process(pEvent->m_pExcepInfo, e);
}
DELETE_EXCEPTION(e);
hResult = DISP_E_EXCEPTION;
}
END_CATCH_ALL
// fill error argument if one is available
if (FAILED(hResult) && pEvent->m_puArgError != NULL && uArgError != -1)
*pEvent->m_puArgError = uArgError;
// fill result code
pEvent->m_hResult = hResult;
return bHandled;
}
