bool UTextProperty::Identical( const void* A, const void* B, uint32 PortFlags ) const
{
const TCppType ValueA = GetPropertyValue(A);
if ( B )
{
const TCppType ValueB = GetPropertyValue(B);
if ( ValueA.IsCultureInvariant() != ValueB.IsCultureInvariant() || ValueA.IsTransient() != ValueB.IsTransient() )
{
//A culture variant text is never equal to a culture invariant text
//A transient text is never equal to a non-transient text
return false;
}
if ( ValueA.IsCultureInvariant() == ValueB.IsCultureInvariant() || ValueA.IsTransient() == ValueB.IsTransient() )
{
//Culture invariant text don't have a namespace/key so we compare the source string
//Transient text don't have a namespace/key or source so we compare the display string
return *FTextInspector::GetDisplayString(ValueA) == *FTextInspector::GetDisplayString(ValueB);
}
#if WITH_EDITOR
return *FTextInspector::GetSourceString(ValueA) == *FTextInspector::GetSourceString(ValueB);
#else
return FTextInspector::GetNamespace(ValueA) == FTextInspector::GetNamespace(ValueB) &&
FTextInspector::GetKey(ValueA) == FTextInspector::GetKey(ValueB);
#endif
}
return FTextInspector::GetDisplayString(ValueA).IsEmpty();
}
bool UTextProperty::Identical( const void* A, const void* B, uint32 PortFlags ) const
{
const TCppType ValueA = GetPropertyValue(A);
if ( B )
{
const TCppType ValueB = GetPropertyValue(B);
if ( ValueA.IsCultureInvariant() != ValueB.IsCultureInvariant() || ValueA.IsTransient() != ValueB.IsTransient() )
{
//A culture variant text is never equal to a culture invariant text
//A transient text is never equal to a non-transient text
return false;
}
if ( ValueA.IsCultureInvariant() == ValueB.IsCultureInvariant() || ValueA.IsTransient() == ValueB.IsTransient() )
{
//Culture invariant text don't have a namespace/key so we compare the source string
//Transient text don't have a namespace/key or source so we compare the display string
return FTextInspector::GetDisplayString(ValueA) == FTextInspector::GetDisplayString(ValueB);
}
if (GIsEditor)
{
return FTextInspector::GetSourceString(ValueA)->Compare(*FTextInspector::GetSourceString(ValueB), ESearchCase::CaseSensitive) == 0;
}
else
{
return FTextInspector::GetNamespace(ValueA) == FTextInspector::GetNamespace(ValueB) &&
FTextInspector::GetKey(ValueA) == FTextInspector::GetKey(ValueB);
}
}
return FTextInspector::GetDisplayString(ValueA).IsEmpty();
}
bool UTextProperty::Identical( const void* A, const void* B, uint32 PortFlags ) const
{
const TCppType ValueA = GetPropertyValue(A);
if ( B )
{
const TCppType ValueB = GetPropertyValue(B);
return Identical_Implementation(ValueA, ValueB, PortFlags);
}
return FTextInspector::GetDisplayString(ValueA).IsEmpty();
}
void UTextProperty::ExportTextItem( FString& ValueStr, const void* PropertyValue, const void* DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope ) const
{
const FText& TextValue = GetPropertyValue(PropertyValue);
if (PortFlags & PPF_ExportCpp)
{
ValueStr += GenerateCppCodeForTextValue(TextValue, FString());
}
else if (PortFlags & PPF_PropertyWindow)
{
if (PortFlags & PPF_Delimited)
{
ValueStr += TEXT("\"");
ValueStr += TextValue.ToString();
ValueStr += TEXT("\"");
}
else
{
ValueStr += TextValue.ToString();
}
}
else
{
FTextStringHelper::WriteToString(ValueStr, TextValue, !!(PortFlags & PPF_Delimited));
}
}
FdoDataValue * CGwsFlatGwsIterator::GetDataValue (FdoString* propertyName)
{
const CGwsPropertyDesc & desc = GetPropertyDescriptor (propertyName);
if (desc.m_name.empty ())
return NULL;
return GetPropertyValue (desc);
}
void CCryScriptInstance::SetManagedObject(MonoObject *newObject, bool allowGC)
{
CScriptObject::SetManagedObject(newObject, allowGC);
IMonoObject *pScriptIdResult = *GetPropertyValue("ScriptId");
m_scriptId = pScriptIdResult->Unbox<int>();
pScriptIdResult->Release();
}
bool ConfigProperty::GetPropertyValue(const char* name, bool default_value)
{
assert(name != NULL);
std::string tmp = GetPropertyValue(name, default_value ? "true" : "false");
return (tmp == "true");
}
// Set value
void UILabelValueTweener::SetValue(const int32 nNewValue, const int32 nDurationInMs)
{
const int32 nCurrent = GetPropertyValue();
// Save target value
SetPropertyValue(nNewValue);
// Start running
SetPropertyRunning(true);
// Start tweener
Start(nCurrent, nNewValue, nDurationInMs, GTTweenInterpolation::Linear, 0.0f);
}
void UTextProperty::SerializeItem( FArchive& Ar, void* Value, int32 MaxReadBytes, void const* Defaults ) const
{
const TCppType PropertyValue = GetPropertyValue(Value);
if ( Ar.IsSaving() && Ar.IsPersistent() && PropertyValue.IsTransient() )
{
const FText ErrorMessage = FText::Format( FText::SerializationFailureError, FText::FromString( FTextInspector::GetDisplayString(PropertyValue) ) );
UE_LOG( LogProperty, Warning, TEXT("%s"), *ErrorMessage.ToString());
SetPropertyValue(Value, ErrorMessage);
}
Ar << *GetPropertyValuePtr(Value);
}
void CPropertyBase::GetPropertyValue(LPCTSTR Name, DWORD Phase, double T, double P, MPropertyValue & Value)
{
long i=PropertyIndex(Name);
if (i>=0)
{
GetPropertyValue(i, Phase, T, P, Value);
return;
}
CString S;
S.Format("%s '%s' not valid", DefinedPropertyMapName(), Name);
throw MMdlException(0, (LPCTSTR)S);
};
NS_IMETHODIMP
nsDOMCSSDeclaration::GetPropertyValue(const nsAString& aPropertyName,
nsAString& aReturn)
{
const nsCSSProperty propID = nsCSSProps::LookupProperty(aPropertyName);
if (propID == eCSSProperty_UNKNOWN) {
aReturn.Truncate();
return NS_OK;
}
return GetPropertyValue(propID, aReturn);
}
void UTextProperty::ExportTextItem( FString& ValueStr, const void* PropertyValue, const void* DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope ) const
{
const FText& TextValue = GetPropertyValue(PropertyValue);
const FString& StringValue = FTextInspector::GetDisplayString(TextValue);
if( !(PortFlags & PPF_Delimited) )
{
ValueStr += StringValue;
}
else if ( StringValue.Len() > 0 )
{
ValueStr += FString::Printf( TEXT("\"%s\""), *(StringValue.ReplaceCharWithEscapedChar()) );
}
}
int ConfigProperty::GetPropertyValue(const char* name, int default_value)
{
assert(name != NULL);
char buf[64] = {0};
sprintf(buf, "%d", default_value);
std::string tmp = GetPropertyValue(name, buf);
int result = atoi(tmp.c_str());
return result;
}
NS_IMETHODIMP
nsDOMCSSDeclaration::RemoveProperty(const nsAString& aPropertyName,
nsAString& aReturn)
{
const nsCSSProperty propID = nsCSSProps::LookupProperty(aPropertyName);
if (propID == eCSSProperty_UNKNOWN) {
aReturn.Truncate();
return NS_OK;
}
nsresult rv = GetPropertyValue(propID, aReturn);
NS_ENSURE_SUCCESS(rv, rv);
return RemoveProperty(propID);
}
char *getMsgString(int messageID) {
char *value, *v2 = NULL;
char *key = messages[0].key;
char *defaultMessage = messages[0].message;
int i, len, len2;
twchar_t wArray[MAXPATHLEN];
len = sizeof(messages)/sizeof(messages[0]);
for (i=0; i<len; i++) {
if (messages[i].id == messageID) {
key = messages[i].key;
defaultMessage = messages[i].message;
break;
}
}
if (msgs_inProgress) {
/* double fault - error generating error msg return default*/
return defaultMessage;
}
msgs_inProgress = TRUE;
if (!msgs_initialized) {
initializeMessages(sysGetLocaleStr());
msgs_initialized = TRUE;
}
value = GetPropertyValue(MsgFileHead, key);
if (value == NULL) {
value = defaultMessage;
}
len2 = DecodeMessage(value, wArray);
v2 = sysWideCharToMBCS(wArray, len2);
msgs_inProgress = FALSE;
if (v2 == NULL) {
return defaultMessage;
} else {
return v2;
}
}
static int GetTotalVideoMemory()
{
if (RootContainer != NULL)
{
// Get device container
IDxDiagContainer* container = GetContainer(RootContainer, L"DxDiag_DisplayDevices");
if (container != NULL)
{
// Get device name
container = GetContainer(container, L"0");
if (container != NULL)
{
const int bufferLength = 256;
WCHAR buffer[bufferLength];
GetPropertyValue(container, L"szDisplayMemoryLocalized", buffer, bufferLength);
// Value in MB is first token in string
return _wtoi(buffer);
}
}
}
// No good!
return -1;
}
QVariant GetPropertyValue( AEditableProperty* theProperty )
{
if (theProperty->Is<EdProperty_Bool>())
{
EdProperty_Bool* pProperty = static_cast< EdProperty_Bool* >( theProperty );
return QVariant(pProperty->Get());
}
else if (theProperty->Is<EdProperty_UInt32>())
{
EdProperty_UInt32* pProperty = static_cast< EdProperty_UInt32* >( theProperty );
return QVariant(pProperty->Get());
}
else if (theProperty->Is<EdProperty_Float>())
{
EdProperty_Float* pProperty = static_cast< EdProperty_Float* >( theProperty );
return QVariant(pProperty->Get());
}
else if (theProperty->Is<EdProperty_Vector3D>())
{
EdProperty_Vector3D* pProperty = static_cast< EdProperty_Vector3D* >( theProperty );
return ToVariant(pProperty->Get());
}
else if (theProperty->Is<EdProperty_Quat>())
{
EdProperty_Quat* pProperty = static_cast< EdProperty_Quat* >( theProperty );
return ToVariant(pProperty->Get());
}
else if (theProperty->Is<EdProperty_Array>())
{
EdProperty_Array* pPropertyArray = static_cast< EdProperty_Array* >( theProperty );
(void)pPropertyArray;
#if 0
QList<QVariant> valueList;
valueList.reserve(pPropertyArray->Num());
for( UINT iProperty = 0; iProperty < pPropertyArray->Num(); iProperty++ )
{
AProperty * pProperty = pPropertyArray->ToPtr()[ iProperty ];
valueList.append( GetPropertyValue( pProperty ) );
}
return QVariant(valueList);
#else
return QVariant();
#endif
}
MX_REMOVE_OLD_CODE
//else if (theProperty->Is<EdProperty_AssetReference>())
//{
// EdProperty_AssetReference* pProperty = static_cast< EdProperty_AssetReference* >( theProperty );
// const SResourceObject* resource = pProperty->Get();
// if( resource != nil )
// {
// return QVariant(QString(resource->edGetEditorInterface()->edToChars(0)));
// }
// else
// {
// return "NULL";
// }
// //return QVariant(QString(EdResourceIdToChars(resource->GetResourceGUID())));
//}
else if (theProperty->Is<EdProperty_String>())
{
EdProperty_String* pProperty = static_cast< EdProperty_String* >( theProperty );
return ToVariant(pProperty->Get());
}
else if (theProperty->Is<EdProperty_ClassGuid>())
{
EdProperty_ClassGuid* pProperty = static_cast< EdProperty_ClassGuid* >( theProperty );
return ToVariant(pProperty->rttiGetTypeName());
}
else if (theProperty->Is<EdProperty_FileTime>())
{
EdProperty_FileTime* pProperty = static_cast< EdProperty_FileTime* >( theProperty );
return ToVariant(pProperty->Get());
}
else if (theProperty->Is<Property_32BitHexId>())
{
Property_32BitHexId* pProperty = static_cast< Property_32BitHexId* >( theProperty );
return ResourceIdToVariant(pProperty->Get());
}
else if (theProperty->Is<EdProperty_ColorRGBA>())
{
EdProperty_ColorRGBA* pProperty = static_cast< EdProperty_ColorRGBA* >( theProperty );
return ColorToVariant(pProperty->Get());
}
else if (theProperty->Is<EdProperty_VoidPointer>())
{
EdProperty_VoidPointer* pProperty = static_cast< EdProperty_VoidPointer* >( theProperty );
return VoidPointerIdToVariant(pProperty->Get());
}
else if (theProperty->Is<EdProperty_Enum>())
{
EdProperty_Enum* pProperty = static_cast< EdProperty_Enum* >( theProperty );
return pProperty->GetCurrEnumItem().name.ToChars();
}
else
{
Unimplemented;
return nil;
}
}
CTString GetItemValue(CEntity *pen, INDEX iColumn, INDEX &iFormat)
{
ASSERT(pen!=NULL);
if(pen==NULL) return CTString("");
CEntityClass *pecEntityClass = pen->GetClass();
CDLLEntityClass *pdllecDllEntityClass = pecEntityClass->ec_pdecDLLClass;
FLOAT3D vOrigin = pen->GetPlacement().pl_PositionVector;
ANGLE3D vAngles = pen->GetPlacement().pl_OrientationAngle;
CTString strResult="";
iFormat=PDF_STRING;
switch( iColumn)
{
case COLUMN_INDEX:
{
INDEX iIndex=dcEntities.GetIndex(pen);
strResult.PrintF("%d", FLOAT(iIndex));
iFormat=PDF_INDEX;
break;
}
case COLUMN_CLASS:
{
strResult=pdllecDllEntityClass->dec_strName;
break;
}
case COLUMN_NAME:
{
strResult=pen->GetName();
break;
}
case COLUMN_DESCRIPTION:
{
strResult=pen->GetDescription();
break;
}
case COLUMN_SECTOR_NAME:
{
CBrushSector *pbsc = pen->GetFirstSectorWithName();
if( pbsc!=NULL)
{
strResult=pbsc->bsc_strName;
}
break;
}
case COLUMN_X:
{
strResult.PrintF("%g", vOrigin(1));
iFormat=PDF_FLOAT;
break;
}
case COLUMN_Y:
{
strResult.PrintF("%g", vOrigin(2));
iFormat=PDF_FLOAT;
break;
}
case COLUMN_Z:
{
strResult.PrintF("%g", vOrigin(3));
iFormat=PDF_FLOAT;
break;
}
case COLUMN_H:
{
strResult.PrintF("%g", vAngles(1));
iFormat=PDF_FLOAT;
break;
}
case COLUMN_P:
{
strResult.PrintF("%g", vAngles(2));
iFormat=PDF_FLOAT;
break;
}
case COLUMN_B:
{
strResult.PrintF("%g", vAngles(3));
iFormat=PDF_FLOAT;
break;
}
case COLUMN_DISTANCE:
{
if( _penForDistanceSort != NULL)
{
FLOAT3D vSelectedOrigin = _penForDistanceSort->GetPlacement().pl_PositionVector;
FLOAT3D fDistance = vOrigin-vSelectedOrigin;
strResult.PrintF("%g", fDistance.Length());
iFormat=PDF_FLOAT;
}
break;
}
case COLUMN_SPAWN_FLAGS:
{
strResult.PrintF("0x%08X", pen->GetSpawnFlags());
break;
}
// entity properties
default:
{
CDLLEntityClass *pdecDLLClass = pen->GetClass()->ec_pdecDLLClass;
// for all classes in hierarchy of this entity
INDEX iPropertyOrder=0;
for(;pdecDLLClass!=NULL; pdecDLLClass = pdecDLLClass->dec_pdecBase)
{
// for all properties
for(INDEX iProperty=0; iProperty<pdecDLLClass->dec_ctProperties; iProperty++)
{
CEntityProperty *pepProperty = &pdecDLLClass->dec_aepProperties[iProperty];
if( pepProperty->ep_strName!=CTString(""))
{
if( iPropertyOrder==iColumn-COLUMN_PROPERTY_START)
{
strResult=GetPropertyValue(pen, pepProperty, iFormat);
return strResult;
}
iPropertyOrder++;
}
}
}
}
}
return strResult;
}
std::string ConfigProperty::GetPropertyValue(const char* name, const std::string& default_value)
{
return GetPropertyValue(name, default_value.c_str());
}
int wmain(int argc, wchar_t* argv[])
{
if (SUCCEEDED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE)))
{
PCWSTR pszAppName = CONSUME_NEXT_ARG(argv, argc);
PCWSTR pszOp = CONSUME_NEXT_ARG(argv, argc);
if (pszOp && ((pszOp[0] == L'-') || (pszOp[0] == L'/')))
{
/* skip - or / */
pszOp++;
if (!_wcsicmp(pszOp, L"?"))
{
Usage(pszAppName);
}
else if (!_wcsicmp(pszOp, L"get"))
{
PCWSTR pszPropertyName = CONSUME_NEXT_ARG(argv, argc);
if (pszPropertyName)
{
PCWSTR pszFileName = CONSUME_NEXT_ARG(argv, argc);
if (pszFileName)
{
GetPropertyValue(pszFileName, pszPropertyName);
}
else
{
wprintf(L"No file name specified.\n");
}
}
else
{
wprintf(L"No property canonical name specified.\n");
}
}
else if (!_wcsicmp(pszOp, L"enum"))
{
PCWSTR pszFileName = CONSUME_NEXT_ARG(argv, argc);
if (pszFileName)
{
EnumerateProperties(pszFileName);
}
else
{
wprintf(L"No file name specified.\n");
}
}
else if (!_wcsicmp(pszOp, L"set"))
{
PCWSTR pszPropertyName = CONSUME_NEXT_ARG(argv, argc);
if (pszPropertyName)
{
PCWSTR pszPropertyValue = CONSUME_NEXT_ARG(argv, argc);
if (pszPropertyValue)
{
PCWSTR pszFileName = CONSUME_NEXT_ARG(argv, argc);
if (pszFileName)
{
SetPropertyValue(pszFileName, pszPropertyName, pszPropertyValue);
}
else
{
wprintf(L"No file name specified.\n");
}
}
else
{
wprintf(L"No property value specified.\n");
}
}
else
{
wprintf(L"No property canonical name specified.\n");
}
}
else if (!_wcsicmp(pszOp, L"info"))
{
PCWSTR pszPropertyName = CONSUME_NEXT_ARG(argv, argc);
if (pszPropertyName)
{
GetPropertyDescription(pszPropertyName);
}
else
{
wprintf(L"No property canonical name specified.\n");
}
}
else
{
wprintf(L"Unrecognized operation specified: -%s\n", pszOp);
Usage(pszAppName);
}
}
else
{
wprintf(L"No operation specified.\n");
Usage(pszAppName);
}
CoUninitialize();
}
return 0;
}
void UTextProperty::SerializeItem( FArchive& Ar, void* Value, void const* Defaults ) const
{
const TCppType PropertyValue = GetPropertyValue(Value);
Ar << *GetPropertyValuePtr(Value);
}
void getset_property( CAMHandle hCam, CAMDeviceInfoPtr pDevInfo, OPTS *pOpts)
{
CAMPropertyDescPtr pProp = 0;
if (validate_property( pDevInfo, pOpts->property)) {
camcli_error( "The device does not support property 0x%04X", pOpts->property);
return;
}
if (GetPropertyDesc( hCam, pOpts->property, &pProp)) {
camcli_error( "Could not get device property description for 0x%04X", pOpts->property);
return;
}
printf( "\n Get/Set Property %s\n", pDevInfo->Model);
printf( " ================ %s\n", underline( pDevInfo->Model));
printf( " Property: 0x%04X\n", pProp->DevicePropertyCode);
printf( " Description: %s\n", GetPropertyName( pDevInfo, pOpts->property));
printf( " DataType: %s\n", GetCodeName( pProp->DataType, CAM_DATATYPE));
printf( " %sValue: ", (pOpts->value ? "Previous" : " Current"));
print_propval( pProp->DataType, pProp->cntCurrentValue, pProp->CurrentValue,
(pProp->FormFlag == CAM_PROP_EnumForm));
printf("\n");
if (pOpts->value) {
uint16_t ret;
CAMPropertyValuePtr pValue = 0;
ret = set_property( hCam, pProp->DevicePropertyCode,
pOpts->value, pProp->DataType);
if (ret == CAMERR_BADPARM)
camcli_error( "Unable to set property value for this datatype");
else
if (ret)
camcli_error( "Unable to set property value - rc= %X", ret);
else {
ret = GetPropertyValue( hCam, pProp->DevicePropertyCode,
pProp->DataType, &pValue);
if (ret == 0) {
printf( " NewValue: ");
print_propval( pValue->DataType, pValue->cntValue, pValue->Value,
(pProp->FormFlag == CAM_PROP_EnumForm));
printf("\n");
}
else
camcli_error( "Unable to get new property value - rc= %X", ret);
}
if (pValue)
free( pValue);
if (pProp)
free( pProp);
return;
}
printf( " DefaultValue: ");
print_propval( pProp->DataType, pProp->cntDefaultValue, pProp->DefaultValue,
(pProp->FormFlag == CAM_PROP_EnumForm));
printf("\n");
if (pProp->GetSet == CAM_PROP_ReadOnly)
printf( " Read/Write: read only\n");
else
printf( " Read/Write: read & write\n");
if (pProp->FormFlag == CAM_PROP_EnumForm) {
if (pProp->Form.Enum.cntSupportedValues) {
printf( " ValueFormat: enumeration\n");
printf( " AllowedValues: ");
print_propval( pProp->DataType, pProp->Form.Enum.cntSupportedValues,
pProp->Form.Enum.SupportedValues, 1);
printf( "\n");
}
}
else
if (pProp->FormFlag == CAM_PROP_RangeForm) {
printf( " ValueFormat: range\n");
printf( " AllowedValues: ");
print_propval( pProp->DataType, 1, pProp->Form.Range.MinimumValue, 1);
printf( " - ");
print_propval( pProp->DataType, 1, pProp->Form.Range.MaximumValue, 1);
printf( "; step size: ");
print_propval( pProp->DataType, 1, pProp->Form.Range.StepSize, 1);
printf( "\n");
}
else
if (pProp->FormFlag != CAM_PROP_None)
printf( " ValueFormat: %02X [not supported]\n", (uint8_t)pProp->FormFlag);
if (pProp)
free( pProp);
return;
}
void GetPropertiesValue(const VTreeTextStyle* inUniformStyles, StyleProperties& ioStyle)
{
if(inUniformStyles)
{
if(ioStyle.fontName)
{
VString vfont;
StyleProperties vstyle;
memset(&vstyle,0,sizeof(StyleProperties));
vstyle.fontName = &vfont;
GetPropertyValue(inUniformStyles, vstyle);
*(ioStyle.fontName) = vfont;
}
if(ioStyle.fontSize)
{
Real vfontsize;
StyleProperties vstyle;
memset(&vstyle,0,sizeof(StyleProperties));
vstyle.fontSize = &vfontsize;
GetPropertyValue(inUniformStyles, vstyle);
*(ioStyle.fontSize) = vfontsize;
}
if(ioStyle.bold)
{
sLONG vbold;
StyleProperties vstyle;
memset(&vstyle,0,sizeof(StyleProperties));
vstyle.bold = &vbold;
GetPropertyValue(inUniformStyles, vstyle);
*(ioStyle.bold) = vbold;
}
if(ioStyle.italic)
{
sLONG vitalic;
StyleProperties vstyle;
memset(&vstyle,0,sizeof(StyleProperties));
vstyle.italic = &vitalic;
GetPropertyValue(inUniformStyles, vstyle);
*(ioStyle.italic) = vitalic;
}
if(ioStyle.underline)
{
sLONG vunderline;
StyleProperties vstyle;
memset(&vstyle,0,sizeof(StyleProperties));
vstyle.underline = &vunderline;
GetPropertyValue(inUniformStyles, vstyle);
*(ioStyle.underline) = vunderline;
}
if(ioStyle.strikeout)
{
sLONG vstrikeout;
StyleProperties vstyle;
memset(&vstyle,0,sizeof(StyleProperties));
vstyle.strikeout = &vstrikeout;
GetPropertyValue(inUniformStyles, vstyle);
*(ioStyle.strikeout) = vstrikeout;
}
if(ioStyle.foreColor)
{
RGBAColor vforeColor;
StyleProperties vstyle;
memset(&vstyle,0,sizeof(StyleProperties));
vstyle.foreColor = &vforeColor;
GetPropertyValue(inUniformStyles, vstyle);
*(ioStyle.foreColor) = vforeColor;
}
if(ioStyle.just)
{
justificationStyle vjust;
StyleProperties vstyle;
memset(&vstyle,0,sizeof(StyleProperties));
vstyle.just = &vjust;
GetPropertyValue(inUniformStyles, vstyle);
*(ioStyle.just) = vjust;
}
}
}
void GetPropertyValue(const VTreeTextStyle* inUniformStyles, StyleProperties& ioStyle)
{
if(inUniformStyles)
{
if(ioStyle.fontName)
{
VString vfont;
vfont = inUniformStyles->GetData()->GetFontName();
if(vfont == "")
{
VTreeTextStyle* parent = inUniformStyles->GetParent();
if(parent)
GetPropertyValue(parent,ioStyle);
else
*(ioStyle.fontName) = vfont;
}
else
*(ioStyle.fontName) = vfont;
}
else if(ioStyle.fontSize)
{
Real vfontsize;
vfontsize = inUniformStyles->GetData()->GetFontSize();
if(vfontsize == -1)
{
VTreeTextStyle* parent = inUniformStyles->GetParent();
if(parent)
GetPropertyValue(parent,ioStyle);
else
*(ioStyle.fontSize) = vfontsize;
}
else
*(ioStyle.fontSize) = vfontsize;
}
else if(ioStyle.bold)
{
sLONG vbold;
vbold = inUniformStyles->GetData()->GetBold();
if(vbold == -1)
{
VTreeTextStyle* parent = inUniformStyles->GetParent();
if(parent)
GetPropertyValue(parent,ioStyle);
else
*(ioStyle.bold) = vbold;
}
else
*(ioStyle.bold) = vbold;
}
else if(ioStyle.italic)
{
sLONG vitalic;
vitalic = inUniformStyles->GetData()->GetItalic();
if(vitalic == -1)
{
VTreeTextStyle* parent = inUniformStyles->GetParent();
if(parent)
GetPropertyValue(parent,ioStyle);
else
*(ioStyle.italic) = vitalic;
}
else
*(ioStyle.italic) = vitalic;
}
else if(ioStyle.underline)
{
sLONG vunderline;
vunderline = inUniformStyles->GetData()->GetUnderline();
if(vunderline == -1)
{
VTreeTextStyle* parent = inUniformStyles->GetParent();
if(parent)
GetPropertyValue(parent,ioStyle);
else
*(ioStyle.underline) = vunderline;
}
else
*(ioStyle.underline) = vunderline;
}
else if(ioStyle.just)
{
justificationStyle vjust;
vjust = inUniformStyles->GetData()->GetJustification();
if(vjust == JST_Notset)
{
VTreeTextStyle* parent = inUniformStyles->GetParent();
if(parent)
GetPropertyValue(parent,ioStyle);
else
*(ioStyle.just) = vjust;
}
else
*(ioStyle.just) = vjust;
}
else if(ioStyle.strikeout)
{
sLONG vstrikeout;
vstrikeout = inUniformStyles->GetData()->GetStrikeout();
if(vstrikeout == -1)
{
VTreeTextStyle* parent = inUniformStyles->GetParent();
if(parent)
GetPropertyValue(parent,ioStyle);
else
*(ioStyle.strikeout) = vstrikeout;
}
else
*(ioStyle.strikeout) = vstrikeout;
}
else if(ioStyle.foreColor)
{
RGBAColor vcolor;
bool hascolor = inUniformStyles->GetData()->GetHasForeColor();
if(!hascolor)
{
VTreeTextStyle* parent = inUniformStyles->GetParent();
if(parent)
GetPropertyValue(parent,ioStyle);
else
*(ioStyle.foreColor) = inUniformStyles->GetData()->GetColor();
}
else
{
*(ioStyle.foreColor) = inUniformStyles->GetData()->GetColor();
}
}
}
}