XnStatus XnFileDevice::ReadStringProperty()
{
XnStatus nRetVal = XN_STATUS_OK;
XnChar strModule[XN_DEVICE_MAX_STRING_LENGTH];
XnChar strProp[XN_DEVICE_MAX_STRING_LENGTH];
XnChar strValue[XN_DEVICE_MAX_STRING_LENGTH];
// read change data
nRetVal = m_pDataPacker->ReadProperty(strModule, strProp, strValue);
XN_IS_STATUS_OK(nRetVal);
nRetVal = HandleStringProperty(strModule, strProp, strValue);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
XnStatus XnFileDevice::HandleNewStream(const XnChar *strType, const XnChar *strName, const XnActualPropertiesHash *pInitialValues)
{
XnStatus nRetVal = XN_STATUS_OK;
// check if we need to ignore that (stream was not removed upon Rewind).
XnNodeInfoMap::Iterator it = m_ignoreNewNodes.End();
if (m_ignoreNewNodes.Find(strName, it) == XN_STATUS_OK)
{
// ignore
return (XN_STATUS_OK);
}
XnProductionNodeType type = GetNodeType(strType);
if (type == -1)
{
XN_LOG_WARNING_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_FILE, "Invalid node type: %s", strType);
}
// find compression type
XnActualIntProperty* pComp = NULL;
nRetVal = pInitialValues->Get(XN_STREAM_PROPERTY_COMPRESSION, (XnProperty*&)pComp);
XN_IS_STATUS_OK(nRetVal);
XnCodecID codecID = XnCodec::GetCodecIDFromCompressionFormat((XnCompressionFormats)pComp->GetValue());
if (codecID == XN_CODEC_NULL)
{
XN_LOG_WARNING_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_FILE, "Invalid compression type: %llu", pComp->GetValue());
}
// notify we have a new node
nRetVal = m_pNotifications->OnNodeAdded(m_pNotificationsCookie, strName, type, codecID);
XN_IS_STATUS_OK(nRetVal);
// we support the mirror capability
nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strName, XN_CAPABILITY_MIRROR, 1);
XN_IS_STATUS_OK(nRetVal);
// we support the extended serialization capability
nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strName, XN_CAPABILITY_EXTENDED_SERIALIZATION, 1);
XN_IS_STATUS_OK(nRetVal);
// now write state
for (XnActualPropertiesHash::ConstIterator it = pInitialValues->Begin(); it != pInitialValues->End(); ++it)
{
XnProperty* pProp = it->Value();
switch (pProp->GetType())
{
case XN_PROPERTY_TYPE_INTEGER:
{
XnActualIntProperty* pIntProp = (XnActualIntProperty*)pProp;
nRetVal = HandleIntProperty(strName, pProp->GetName(), pIntProp->GetValue());
}
break;
case XN_PROPERTY_TYPE_REAL:
{
XnActualRealProperty* pRealProp = (XnActualRealProperty*)pProp;
nRetVal = HandleRealProperty(strName, pProp->GetName(), pRealProp->GetValue());
}
break;
case XN_PROPERTY_TYPE_STRING:
{
XnActualStringProperty* pStrProp = (XnActualStringProperty*)pProp;
nRetVal = HandleStringProperty(strName, pProp->GetName(), pStrProp->GetValue());
}
break;
case XN_PROPERTY_TYPE_GENERAL:
{
XnActualGeneralProperty* pGenProp = (XnActualGeneralProperty*)pProp;
nRetVal = HandleGeneralProperty(strName, pProp->GetName(), pGenProp->GetValue());
}
break;
default:
XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_FILE, "Unknown property type: %d", pProp->GetType());
}
XN_IS_STATUS_OK(nRetVal);
}
// at this stage, a node should exist with this name
xn::ProductionNode node;
nRetVal = m_context.GetProductionNodeByName(strName, node);
XN_IS_STATUS_OK(nRetVal);
// S2D & RW
if (type == XN_NODE_TYPE_DEPTH)
{
nRetVal = UpdateS2DTables(xn::DepthGenerator(node));
XN_IS_STATUS_OK(nRetVal);
nRetVal = UpdateRWData(xn::DepthGenerator(node));
XN_IS_STATUS_OK(nRetVal);
}
// notify end-of-state
nRetVal = m_pNotifications->OnNodeStateReady(m_pNotificationsCookie, strName);
XN_IS_STATUS_OK(nRetVal);
// add it to the map
XnNodeInfo nodeInfo = {0};
nRetVal = m_nodeInfoMap.Set(strName, nodeInfo);
XN_IS_STATUS_OK(nRetVal);
// create codec
nRetVal = CreateCodec(node);
XN_IS_STATUS_OK(nRetVal);
// check IR compatibility
nRetVal = CheckIRCompatibility(node);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
//+---------------------------------------------------------------
//
// Member: PROPERTYDESC::HandleStyleComponentProperty, public
//
// Synopsis: Helper for getting/setting url style sheet properties...
// url(string)
//
// Arguments: dwOpCode -- encodes the incoming type (PROPTYPE_FLAG) in the upper WORD and
// the opcode in the lower WORD (HANDLERPROP_FLAGS)
// PROPTYPE_EMPTY means the 'native' type (long in this case)
// pv -- points to the 'media' the value is stored for the get and set
// pObject -- object owns the property
// pSubObject -- subobject storing the property (could be the main object)
//
//----------------------------------------------------------------
HRESULT PROPERTYDESC::HandleStyleComponentProperty(DWORD dwOpCode, void* pv, CBase* pObject, CVoid* pSubObject) const
{
HRESULT hr = S_OK;
VARIANT varDest;
size_t nLenIn = (size_t) -1;
DWORD dispid = GetBasicPropParams()->dispid;
BSTR bstrTemp; // Used by some of the stream writers
BOOL fTDPropertyValue=FALSE; // If this is a SET of a text-decoration sub-property, this is the value
WORD wFlags = 0;
if(ISSET(dwOpCode))
{
Assert(!(ISSTREAM(dwOpCode))); // we can't do this yet...
switch(dispid)
{
case DISPID_A_TEXTDECORATIONNONE:
case DISPID_A_TEXTDECORATIONUNDERLINE:
case DISPID_A_TEXTDECORATIONOVERLINE:
case DISPID_A_TEXTDECORATIONLINETHROUGH:
case DISPID_A_TEXTDECORATIONBLINK:
Assert(PROPTYPE(dwOpCode)==PROPTYPE_VARIANT && "Text-decoration subproperties must take variants!");
Assert(V_VT((VARIANT*)pv)==VT_BOOL && "Text-decoration subproperties must take BOOLEANs!");
fTDPropertyValue = !!((VARIANT*)pv)->boolVal;
break;
default:
switch(PROPTYPE(dwOpCode))
{
case PROPTYPE_VARIANT:
if(V_VT((VARIANT*)pv) == VT_BSTR)
{
pv = (void*)V_BSTR((VARIANT*)pv);
}
else
{
hr = VariantChangeTypeSpecial(&varDest, (VARIANT*)pv, VT_BSTR);
if(hr)
{
goto Cleanup;
}
pv = V_BSTR(&varDest);
}
//intentional fallthrough
case PROPTYPE_LPWSTR:
switch(dispid)
{
case DISPID_A_BACKGROUNDIMAGE:
case DISPID_A_LISTSTYLEIMAGE:
case DISPID_A_FONTFACESRC:
nLenIn = ValidStyleUrl((TCHAR*)pv);
if(OPCODE(dwOpCode) == HANDLEPROP_VALUE)
{
if(!nLenIn && _tcsicmp((TCHAR*)pv, _T("none")))
{
hr = E_INVALIDARG;
goto Cleanup;
}
}
break;
case DISPID_A_BEHAVIOR:
nLenIn = pv ? _tcslen((TCHAR*)pv) : 0;
break;
}
break;
default:
Assert(FALSE); // We shouldn't get here.
}
break;
}
switch(dispid)
{
case DISPID_A_LISTSTYLEIMAGE:
case DISPID_A_BACKGROUNDIMAGE:
case DISPID_A_FONTFACESRC:
case DISPID_A_BEHAVIOR:
if(nLenIn && (nLenIn!=(size_t)-1))
{
if(DISPID_A_BEHAVIOR == dispid)
{
hr = HandleStringProperty(dwOpCode, (TCHAR*)pv, pObject, pSubObject);
}
else
{
TCHAR* pch = (TCHAR*)pv;
TCHAR* psz = pch + 4;
TCHAR* quote = NULL;
TCHAR* pszEnd;
TCHAR terminator;
while(_istspace(*psz))
{
psz++;
}
if(*psz==_T('\'') || *psz==_T('"'))
{
quote = psz++;
}
nLenIn--; // Skip back over the ')' character - we know there is one, because ValidStyleUrl passed this string.
pszEnd = pch + nLenIn - 1;
while(_istspace(*pszEnd) && (pszEnd>psz))
{
pszEnd--;
}
if(quote && (*pszEnd==*quote))
{
pszEnd--;
}
terminator = *(pszEnd+1);
*(pszEnd+1) = _T('\0');
hr = HandleStringProperty(dwOpCode, psz, pObject, pSubObject);
*(pszEnd+1) = terminator;
}
}
else
{
if(!pv || !*(TCHAR*)pv)
{
// Empty string - delete the entry.
CAttrArray** ppAA = (CAttrArray**)pSubObject;
if(*ppAA)
{
(*ppAA)->FindSimpleAndDelete(dispid, CAttrValue::AA_StyleAttribute, NULL);
}
}
else if(!_tcsicmp((TCHAR*)pv, _T("none")))
{
hr = HandleStringProperty(dwOpCode, (void*)_T(""), pObject, pSubObject);
}
else
{
hr = E_INVALIDARG;
}
}
break;
case DISPID_A_BACKGROUND:
hr = ParseBackgroundProperty((CAttrArray**)pSubObject, pObject, OPERATION(dwOpCode),
(TCHAR*)pv, (OPCODE(dwOpCode)==HANDLEPROP_VALUE));
break;
case DISPID_A_FONT:
if(pv && FindSystemFontByName((TCHAR*)pv)!=sysfont_non_system)
{
hr = HandleStringProperty(dwOpCode, pv, pObject, pSubObject);
}
else
{
hr = ParseFontProperty((CAttrArray**)pSubObject, pObject, OPERATION(dwOpCode), (TCHAR*)pv);
}
break;
case DISPID_A_LAYOUTGRID:
hr = ParseLayoutGridProperty((CAttrArray**)pSubObject, pObject, OPERATION(dwOpCode), (TCHAR*)pv);
break;
case DISPID_A_TEXTAUTOSPACE:
if(dwOpCode & HANDLEPROP_IMPORTANT)
{
wFlags |= CAttrValue::AA_Extra_Important;
}
if(dwOpCode & HANDLEPROP_IMPLIED)
{
wFlags |= CAttrValue::AA_Extra_Implied;
}
hr = ParseTextAutospaceProperty((CAttrArray**)pSubObject, (LPCTSTR)pv, wFlags);
break;
case DISPID_A_TEXTDECORATION:
if(dwOpCode & HANDLEPROP_IMPORTANT)
{
wFlags |= CAttrValue::AA_Extra_Important;
}
if(dwOpCode & HANDLEPROP_IMPLIED)
{
wFlags |= CAttrValue::AA_Extra_Implied;
}
hr = ParseTextDecorationProperty((CAttrArray**)pSubObject, (LPCTSTR)pv, wFlags);
break;
case DISPID_A_TEXTDECORATIONNONE:
case DISPID_A_TEXTDECORATIONUNDERLINE:
case DISPID_A_TEXTDECORATIONOVERLINE:
case DISPID_A_TEXTDECORATIONLINETHROUGH:
case DISPID_A_TEXTDECORATIONBLINK:
{
VARIANT v;
v.vt = VT_I4;
v.lVal = 0;
if(*((CAttrArray**)pSubObject))
{
// See if we already have a text-decoration value
CAttrValue* pAV = (*((CAttrArray**)pSubObject))->Find(DISPID_A_TEXTDECORATION, CAttrValue::AA_Attribute);
if(pAV)
{
// We do! Copy its value into our working variant
v.lVal = pAV->GetLong();
}
}
switch(dispid)
{
case DISPID_A_TEXTDECORATIONNONE:
if(fTDPropertyValue)
{
v.lVal = TD_NONE; // "none" clears all the other properties (unlike the other properties)
}
else
{
v.lVal &= ~TD_NONE;
}
break;
case DISPID_A_TEXTDECORATIONUNDERLINE:
if(fTDPropertyValue)
{
v.lVal |= TD_UNDERLINE;
}
else
{
v.lVal &= ~TD_UNDERLINE;
}
break;
case DISPID_A_TEXTDECORATIONOVERLINE:
if(fTDPropertyValue)
{
v.lVal |= TD_OVERLINE;
}
else
{
v.lVal &= ~TD_OVERLINE;
}
break;
case DISPID_A_TEXTDECORATIONLINETHROUGH:
if(fTDPropertyValue)
{
v.lVal |= TD_LINETHROUGH;
}
else
{
v.lVal &= ~TD_LINETHROUGH;
}
break;
case DISPID_A_TEXTDECORATIONBLINK:
if(fTDPropertyValue)
{
v.lVal |= TD_BLINK;
}
else
{
v.lVal &= ~TD_BLINK;
}
break;
}
if(dwOpCode & HANDLEPROP_IMPORTANT)
{
wFlags |= CAttrValue::AA_Extra_Important;
}
if ( dwOpCode & HANDLEPROP_IMPLIED)
{
wFlags |= CAttrValue::AA_Extra_Implied;
}
hr = CAttrArray::Set((CAttrArray**)pSubObject, DISPID_A_TEXTDECORATION, &v,
(PROPERTYDESC*)&s_propdescCStyletextDecoration, CAttrValue::AA_StyleAttribute, wFlags);
}
dispid = DISPID_A_TEXTDECORATION; // This is so we call OnPropertyChange for the right property below.
break;
case DISPID_A_MARGIN:
case DISPID_A_PADDING:
hr = ParseExpandProperty((CAttrArray**)pSubObject, pObject, OPERATION(dwOpCode), (TCHAR*)pv, dispid, TRUE);
break;
case DISPID_A_BORDERCOLOR:
case DISPID_A_BORDERWIDTH:
case DISPID_A_BORDERSTYLE:
hr = ParseExpandProperty((CAttrArray**)pSubObject, pObject, OPERATION(dwOpCode), (TCHAR*)pv, dispid, FALSE);
break;
case DISPID_A_STYLETEXT:
{
LPTSTR lpszStyleText = (TCHAR*)pv;
CAttrArray** ppAA = (CAttrArray**)pSubObject;
if(*ppAA)
{
(*ppAA)->Free();
}
if(lpszStyleText && *lpszStyleText)
{
CStyle* pStyle = DYNCAST(CStyle, pObject);
Assert(pStyle);
pStyle->MaskPropertyChanges(TRUE);
AssertSz(FALSE, "must improve");
pStyle->MaskPropertyChanges(FALSE);
}
}
break;
case DISPID_A_BORDERTOP:
case DISPID_A_BORDERRIGHT:
case DISPID_A_BORDERBOTTOM:
case DISPID_A_BORDERLEFT:
hr = ParseAndExpandBorderSideProperty((CAttrArray**)pSubObject, pObject, OPERATION(dwOpCode), (TCHAR*)pv, dispid);
break;
case DISPID_A_BORDER:
hr = ParseBorderProperty((CAttrArray**)pSubObject, pObject, OPERATION(dwOpCode), (TCHAR*)pv);
break;
case DISPID_A_LISTSTYLE:
hr = ParseListStyleProperty((CAttrArray**)pSubObject, pObject, OPERATION(dwOpCode), (TCHAR*)pv);
break;
case DISPID_A_BACKGROUNDPOSITION:
hr = ParseBackgroundPositionProperty((CAttrArray**)pSubObject, pObject, OPERATION(dwOpCode), (TCHAR*)pv);
break;
case DISPID_A_CLIP:
hr = ParseClipProperty((CAttrArray**)pSubObject, pObject, OPERATION(dwOpCode), (TCHAR*)pv);
break;
default:
Assert("Attempting to set an unknown type of CStyleComponent!");
}
if(hr)
{
goto Cleanup;
}
else
{
// Note that dispid reflects the property that changed, not what was set -
// e.g., textDecorationUnderline has been changed to textDecoration.
if(dwOpCode & HANDLEPROP_AUTOMATION)
{
CBase::CLock Lock(pObject);
hr = pObject->OnPropertyChange(dispid, GetdwFlags());
}
}
}
else
{
// GET value from data
switch(OPCODE(dwOpCode))
{
case HANDLEPROP_STREAM:
{
IStream* pis = (IStream*)pv;
switch(dispid)
{
case DISPID_A_LISTSTYLEIMAGE:
case DISPID_A_BACKGROUNDIMAGE:
case DISPID_A_BEHAVIOR:
case DISPID_A_FONTFACESRC:
if((*(CAttrArray**)pSubObject)->Find(dispid, CAttrValue::AA_Attribute))
{
BSTR bstrSub;
hr = HandleStringProperty(HANDLEPROP_AUTOMATION|(PROPTYPE_BSTR<<16),
&bstrSub, pObject, pSubObject);
if(hr == S_OK)
{
if(bstrSub && *bstrSub)
{ // This is a normal url.
hr = pis->Write(_T("url("), 4*sizeof(TCHAR), NULL);
if(!hr)
{
hr = pis->Write(bstrSub, FormsStringLen(bstrSub)*sizeof(TCHAR), NULL);
if(!hr)
{
hr = pis->Write(_T(")"), 1*sizeof(TCHAR), NULL);
}
}
}
else
{ // We only get here if a NULL string was stored in the array; i.e., the value is NONE.
hr = pis->Write(_T("none"), 4*sizeof(TCHAR), NULL);
}
FormsFreeString(bstrSub);
}
}
break;
case DISPID_A_BACKGROUND:
hr = WriteBackgroundStyleToBSTR(*(CAttrArray**)pSubObject, &bstrTemp);
if(hr == S_OK)
{
hr = pis->Write(bstrTemp, FormsStringLen(bstrTemp)*sizeof(TCHAR), NULL);
FormsFreeString(bstrTemp);
}
break;
case DISPID_A_TEXTAUTOSPACE:
// We need to cook up this property.
hr = WriteTextAutospaceToBSTR(*(CAttrArray**)pSubObject, &bstrTemp);
if(hr == S_OK)
{
hr = pis->Write(bstrTemp, FormsStringLen(bstrTemp)*sizeof(TCHAR), NULL);
FormsFreeString(bstrTemp);
}
break;
case DISPID_A_TEXTDECORATION:
// We need to cook up this property.
hr = WriteTextDecorationToBSTR(*(CAttrArray**)pSubObject, &bstrTemp);
if(hr == S_OK)
{
hr = pis->Write(bstrTemp, FormsStringLen(bstrTemp)*sizeof(TCHAR), NULL);
FormsFreeString(bstrTemp);
}
break;
case DISPID_A_BORDERTOP:
case DISPID_A_BORDERRIGHT:
case DISPID_A_BORDERBOTTOM:
case DISPID_A_BORDERLEFT:
hr = WriteBorderSidePropertyToBSTR(dispid, *(CAttrArray**)pSubObject, &bstrTemp);
if(hr == S_OK)
{
hr = pis->Write(bstrTemp, FormsStringLen(bstrTemp)*sizeof(TCHAR), NULL);
FormsFreeString(bstrTemp);
}
break;
case DISPID_A_BORDER:
hr = WriteBorderToBSTR(*(CAttrArray**)pSubObject, &bstrTemp);
if(hr == S_OK)
{
hr = pis->Write(bstrTemp, FormsStringLen(bstrTemp)*sizeof(TCHAR), NULL);
FormsFreeString(bstrTemp);
}
break;
case DISPID_A_MARGIN:
case DISPID_A_PADDING:
case DISPID_A_BORDERCOLOR:
case DISPID_A_BORDERWIDTH:
case DISPID_A_BORDERSTYLE:
hr = WriteExpandedPropertyToBSTR(dispid, *(CAttrArray**)pSubObject, &bstrTemp);
if(hr == S_OK)
{
hr = pis->Write(bstrTemp, FormsStringLen(bstrTemp)*sizeof(TCHAR), NULL);
FormsFreeString(bstrTemp);
}
break;
case DISPID_A_LISTSTYLE:
hr = WriteListStyleToBSTR(*(CAttrArray**)pSubObject, &bstrTemp);
if(hr == S_OK)
{
hr = pis->Write(bstrTemp, FormsStringLen(bstrTemp)*sizeof(TCHAR), NULL);
FormsFreeString(bstrTemp);
}
break;
case DISPID_A_BACKGROUNDPOSITION:
hr = WriteBackgroundPositionToBSTR(*(CAttrArray**)pSubObject, &bstrTemp);
if(hr == S_OK)
{
hr = pis->Write(bstrTemp, FormsStringLen(bstrTemp)*sizeof(TCHAR), NULL);
FormsFreeString(bstrTemp);
}
break;
case DISPID_A_FONT:
if((*(CAttrArray**)pSubObject)->Find(DISPID_A_FONT, CAttrValue::AA_Attribute))
{
hr = HandleStringProperty(dwOpCode, pv, pObject, pSubObject);
}
else
{
// We need to cook up a "font" property.
hr = WriteFontToBSTR(*(CAttrArray**)pSubObject, &bstrTemp);
if(!hr)
{
if(*bstrTemp)
{
hr = pis->Write(bstrTemp, FormsStringLen(bstrTemp)*sizeof(TCHAR), NULL);
}
FormsFreeString(bstrTemp);
}
}
break;
case DISPID_A_LAYOUTGRID:
// We need to cook up a "layout grid" property.
hr = WriteLayoutGridToBSTR(*(CAttrArray**)pSubObject, &bstrTemp);
if(!hr)
{
if(*bstrTemp)
{
hr = pis->Write(bstrTemp, FormsStringLen(bstrTemp)*sizeof(TCHAR), NULL);
}
FormsFreeString(bstrTemp);
}
break;
case DISPID_A_CLIP:
// We need to cook up a "clip" property with the "rect" shape.
hr = WriteClipToBSTR(*(CAttrArray**)pSubObject, &bstrTemp);
if(!hr)
{
if(*bstrTemp)
{
hr = pis->Write(bstrTemp, FormsStringLen(bstrTemp)*sizeof(TCHAR), NULL);
}
FormsFreeString(bstrTemp);
}
break;
case DISPID_A_STYLETEXT:
hr = WriteStyleToBSTR(pObject, *(CAttrArray**)pSubObject, &bstrTemp, FALSE);
if(!hr)
{
if(*bstrTemp)
{
hr = pis->Write(bstrTemp, _tcslen(bstrTemp)*sizeof(TCHAR), NULL);
}
FormsFreeString(bstrTemp);
}
break;
}
}
break;
default:
{
BSTR* pbstr;
switch(PROPTYPE(dwOpCode))
{
case PROPTYPE_VARIANT:
V_VT((VARIANT*)pv) = VT_BSTR;
pbstr = &(((VARIANT*)pv)->bstrVal);
break;
case PROPTYPE_BSTR:
pbstr = (BSTR*)pv;
break;
default:
Assert("Can't get anything but a VARIANT or BSTR for style component properties!");
hr = S_FALSE;
goto Cleanup;
}
switch(dispid)
{
case DISPID_A_BACKGROUND:
hr = WriteBackgroundStyleToBSTR(*(CAttrArray**)pSubObject, pbstr);
break;
case DISPID_A_LISTSTYLEIMAGE:
case DISPID_A_BACKGROUNDIMAGE:
case DISPID_A_FONTFACESRC:
case DISPID_A_BEHAVIOR:
{
CString cstr;
if((*(CAttrArray**)pSubObject)->Find(dispid, CAttrValue::AA_Attribute))
{
BSTR bstrSub;
hr = HandleStringProperty(HANDLEPROP_AUTOMATION|(PROPTYPE_BSTR<<16),
&bstrSub, pObject, pSubObject);
if(hr == S_OK)
{
if(bstrSub && *bstrSub)
{
// CONSIDER (alexz) using Format, to remove the memallocs here
if(dispid != DISPID_A_BEHAVIOR)
{
cstr.Set(_T("url("));
}
cstr.Append(bstrSub);
if(dispid != DISPID_A_BEHAVIOR)
{
cstr.Append(_T(")"));
}
}
else
{
// We only get here if a NULL string was stored in the array; i.e., the value is NONE.
cstr.Set(_T("none"));
}
FormsFreeString(bstrSub);
}
}
hr = cstr.AllocBSTR(pbstr);
}
break;
case DISPID_A_TEXTAUTOSPACE:
hr = WriteTextAutospaceToBSTR(*(CAttrArray**)pSubObject, pbstr);
break;
case DISPID_A_TEXTDECORATION:
hr = WriteTextDecorationToBSTR(*(CAttrArray**)pSubObject, pbstr);
break;
case DISPID_A_TEXTDECORATIONNONE:
case DISPID_A_TEXTDECORATIONUNDERLINE:
case DISPID_A_TEXTDECORATIONOVERLINE:
case DISPID_A_TEXTDECORATIONLINETHROUGH:
case DISPID_A_TEXTDECORATIONBLINK:
if(PROPTYPE(dwOpCode) != PROPTYPE_VARIANT)
{
Assert("Can't get/set text-decoration subproperties as anything but VARIANTs!");
hr = S_FALSE;
goto Cleanup;
}
V_VT((VARIANT*)pv) = VT_BOOL;
((VARIANT*)pv)->boolVal = 0;
if(*((CAttrArray**)pSubObject))
{
// See if we already have a text-decoration value
CAttrValue* pAV = (*((CAttrArray**)pSubObject))->Find(DISPID_A_TEXTDECORATION, CAttrValue::AA_Attribute);
if(pAV)
{ // We do! Copy its value into our working variant
long lVal = pAV->GetLong();
switch(dispid)
{
case DISPID_A_TEXTDECORATIONNONE:
lVal &= TD_NONE;
break;
case DISPID_A_TEXTDECORATIONUNDERLINE:
lVal &= TD_UNDERLINE;
break;
case DISPID_A_TEXTDECORATIONOVERLINE:
lVal &= TD_OVERLINE;
break;
case DISPID_A_TEXTDECORATIONLINETHROUGH:
lVal &= TD_LINETHROUGH;
break;
case DISPID_A_TEXTDECORATIONBLINK:
lVal &= TD_BLINK;
break;
}
if(lVal)
{
((VARIANT*)pv)->boolVal = -1;
}
}
}
break;
case DISPID_A_BORDERTOP:
case DISPID_A_BORDERRIGHT:
case DISPID_A_BORDERBOTTOM:
case DISPID_A_BORDERLEFT:
hr = WriteBorderSidePropertyToBSTR(dispid, *(CAttrArray**)pSubObject, pbstr);
break;
case DISPID_A_BORDER:
hr = WriteBorderToBSTR(*(CAttrArray**)pSubObject, pbstr);
break;
case DISPID_A_MARGIN:
case DISPID_A_PADDING:
case DISPID_A_BORDERCOLOR:
case DISPID_A_BORDERWIDTH:
case DISPID_A_BORDERSTYLE:
hr = WriteExpandedPropertyToBSTR(dispid, *(CAttrArray**)pSubObject, pbstr);
break;
case DISPID_A_LISTSTYLE:
hr = WriteListStyleToBSTR(*(CAttrArray**)pSubObject, pbstr);
break;
case DISPID_A_BACKGROUNDPOSITION:
hr = WriteBackgroundPositionToBSTR(*(CAttrArray**)pSubObject, pbstr);
break;
case DISPID_A_FONT:
if((*(CAttrArray**)pSubObject)->Find(DISPID_A_FONT, CAttrValue::AA_Attribute))
{
hr = HandleStringProperty(dwOpCode, pv, pObject, pSubObject);
}
else
{
// We need to cook up a "font" property.
hr = WriteFontToBSTR(*(CAttrArray**)pSubObject, pbstr);
}
break;
case DISPID_A_LAYOUTGRID:
hr = WriteLayoutGridToBSTR(*(CAttrArray**)pSubObject, pbstr);
break;
case DISPID_A_STYLETEXT:
hr = WriteStyleToBSTR(pObject, *(CAttrArray**)pSubObject, pbstr, FALSE);
break;
case DISPID_A_CLIP:
// We need to cook up a "clip" property with the "rect" shape.
hr = WriteClipToBSTR(*(CAttrArray**)pSubObject, pbstr);
break;
default:
Assert("Unrecognized type being handled by CStyleUrl handler!" && FALSE);
break;
}
if(hr == S_FALSE)
{
hr = FormsAllocString(_T(""), pbstr);
}
}
break;
}
}
Cleanup:
RRETURN1(hr, S_FALSE);
}
