PRBool
nsSVGElement::ParseAttribute(PRInt32 aNamespaceID,
nsIAtom* aAttribute,
const nsAString& aValue,
nsAttrValue& aResult)
{
// Parse value
nsCOMPtr<nsISVGValue> svg_value;
const nsAttrValue* val = mAttrsAndChildren.GetAttr(aAttribute, aNamespaceID);
if (val) {
// Found the attr in the list.
if (val->Type() == nsAttrValue::eSVGValue) {
svg_value = val->GetSVGValue();
}
}
else {
// Could be a mapped attribute.
svg_value = GetMappedAttribute(aNamespaceID, aAttribute);
}
if (svg_value) {
// We want to prevent DidModifySVGObservable from running if we
// come in this route, otherwise AttributeChanged() gets called
// twice (once through DidMOdifySVGObservable, once through SetAttr).
mSuppressNotification = PR_TRUE;
if (NS_FAILED(svg_value->SetValueString(aValue))) {
// The value was rejected. This happens e.g. in a XUL template
// when trying to set a value like "?x" on a value object that
// expects a length.
// To accommodate this "erroneous" value, we'll insert a proxy
// object between ourselves and the actual value object:
ReportAttributeParseFailure(GetOwnerDoc(), aAttribute, aValue);
nsCOMPtr<nsISVGValue> proxy;
nsresult rv =
NS_CreateSVGStringProxyValue(svg_value, getter_AddRefs(proxy));
// Failure means we'll store this attr as a string, not an SVGValue, but
// that's the best we can do short of throwing outright.
NS_ENSURE_SUCCESS(rv, PR_FALSE);
svg_value->RemoveObserver(this);
ResetOldStyleBaseType(svg_value);
proxy->SetValueString(aValue);
proxy->AddObserver(this);
aResult.SetTo(proxy);
}
else {
aResult.SetTo(svg_value);
}
mSuppressNotification = PR_FALSE;
return PR_TRUE;
}
nsresult rv = NS_OK;
PRBool foundMatch = PR_FALSE;
if (aNamespaceID == kNameSpaceID_None) {
// Check for nsSVGLength2 attribute
LengthAttributesInfo lengthInfo = GetLengthInfo();
PRUint32 i;
for (i = 0; i < lengthInfo.mLengthCount; i++) {
if (aAttribute == *lengthInfo.mLengthInfo[i].mName) {
rv = lengthInfo.mLengths[i].SetBaseValueString(aValue, this, PR_FALSE);
if (NS_FAILED(rv)) {
lengthInfo.Reset(i);
}
foundMatch = PR_TRUE;
break;
}
}
if (!foundMatch) {
// Check for nsSVGNumber2 attribute
NumberAttributesInfo numberInfo = GetNumberInfo();
for (i = 0; i < numberInfo.mNumberCount; i++) {
if (aAttribute == *numberInfo.mNumberInfo[i].mName) {
if (i + 1 < numberInfo.mNumberCount &&
aAttribute == *numberInfo.mNumberInfo[i + 1].mName) {
rv = ParseNumberOptionalNumber(aValue, i, i + 1);
if (NS_FAILED(rv)) {
numberInfo.Reset(i + 1);
}
} else {
rv = numberInfo.mNumbers[i].SetBaseValueString(aValue, this, PR_FALSE);
}
if (NS_FAILED(rv)) {
numberInfo.Reset(i);
}
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check for nsSVGInteger attribute
IntegerAttributesInfo integerInfo = GetIntegerInfo();
for (i = 0; i < integerInfo.mIntegerCount; i++) {
if (aAttribute == *integerInfo.mIntegerInfo[i].mName) {
if (i + 1 < integerInfo.mIntegerCount &&
aAttribute == *integerInfo.mIntegerInfo[i + 1].mName) {
rv = ParseIntegerOptionalInteger(aValue, i, i + 1);
if (NS_FAILED(rv)) {
integerInfo.Reset(i + 1);
}
} else {
rv = integerInfo.mIntegers[i].SetBaseValueString(aValue, this, PR_FALSE);
}
if (NS_FAILED(rv)) {
integerInfo.Reset(i);
}
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check for nsSVGAngle attribute
AngleAttributesInfo angleInfo = GetAngleInfo();
for (i = 0; i < angleInfo.mAngleCount; i++) {
if (aAttribute == *angleInfo.mAngleInfo[i].mName) {
rv = angleInfo.mAngles[i].SetBaseValueString(aValue, this, PR_FALSE);
if (NS_FAILED(rv)) {
angleInfo.Reset(i);
}
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check for nsSVGBoolean attribute
BooleanAttributesInfo booleanInfo = GetBooleanInfo();
for (i = 0; i < booleanInfo.mBooleanCount; i++) {
if (aAttribute == *booleanInfo.mBooleanInfo[i].mName) {
rv = booleanInfo.mBooleans[i].SetBaseValueString(aValue, this, PR_FALSE);
if (NS_FAILED(rv)) {
booleanInfo.Reset(i);
}
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check for nsSVGEnum attribute
EnumAttributesInfo enumInfo = GetEnumInfo();
for (i = 0; i < enumInfo.mEnumCount; i++) {
if (aAttribute == *enumInfo.mEnumInfo[i].mName) {
rv = enumInfo.mEnums[i].SetBaseValueString(aValue, this, PR_FALSE);
if (NS_FAILED(rv)) {
enumInfo.Reset(i);
}
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check for nsSVGViewBox attribute
if (aAttribute == nsGkAtoms::viewBox) {
nsSVGViewBox* viewBox = GetViewBox();
if (viewBox) {
rv = viewBox->SetBaseValueString(aValue, this, PR_FALSE);
if (NS_FAILED(rv)) {
viewBox->Init();
}
foundMatch = PR_TRUE;
}
// Check for nsSVGPreserveAspectRatio attribute
} else if (aAttribute == nsGkAtoms::preserveAspectRatio) {
nsSVGPreserveAspectRatio *preserveAspectRatio =
GetPreserveAspectRatio();
if (preserveAspectRatio) {
rv = preserveAspectRatio->SetBaseValueString(aValue, this, PR_FALSE);
if (NS_FAILED(rv)) {
preserveAspectRatio->Init();
}
foundMatch = PR_TRUE;
}
}
}
}
if (!foundMatch) {
// Check for nsSVGString attribute
StringAttributesInfo stringInfo = GetStringInfo();
for (PRUint32 i = 0; i < stringInfo.mStringCount; i++) {
if (aNamespaceID == stringInfo.mStringInfo[i].mNamespaceID &&
aAttribute == *stringInfo.mStringInfo[i].mName) {
stringInfo.mStrings[i].SetBaseValue(aValue, this, PR_FALSE);
foundMatch = PR_TRUE;
break;
}
}
}
if (foundMatch) {
if (NS_FAILED(rv)) {
ReportAttributeParseFailure(GetOwnerDoc(), aAttribute, aValue);
return PR_FALSE;
}
aResult.SetTo(aValue);
return PR_TRUE;
}
return nsSVGElementBase::ParseAttribute(aNamespaceID, aAttribute, aValue,
aResult);
}
nsresult
nsSVGElement::UnsetAttr(PRInt32 aNamespaceID, nsIAtom* aName,
PRBool aNotify)
{
PRBool foundMatch = PR_FALSE;
if (aNamespaceID == kNameSpaceID_None) {
// If this is an svg presentation attribute, remove rule to force an update
if (IsAttributeMapped(aName))
mContentStyleRule = nsnull;
if (IsEventName(aName)) {
nsIEventListenerManager* manager = GetListenerManager(PR_FALSE);
if (manager) {
nsIAtom* eventName = GetEventNameForAttr(aName);
manager->RemoveScriptEventListener(eventName);
}
foundMatch = PR_TRUE;
}
if (!foundMatch) {
// Check if this is a length attribute going away
LengthAttributesInfo lenInfo = GetLengthInfo();
for (PRUint32 i = 0; i < lenInfo.mLengthCount; i++) {
if (aName == *lenInfo.mLengthInfo[i].mName) {
lenInfo.Reset(i);
DidChangeLength(i, PR_FALSE);
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check if this is a number attribute going away
NumberAttributesInfo numInfo = GetNumberInfo();
for (PRUint32 i = 0; i < numInfo.mNumberCount; i++) {
if (aName == *numInfo.mNumberInfo[i].mName) {
if (i + 1 < numInfo.mNumberCount &&
aName == *numInfo.mNumberInfo[i + 1].mName) {
// found a number-optional-number
numInfo.Reset(i + 1);
DidChangeNumber(i + 1, PR_FALSE);
}
numInfo.Reset(i);
DidChangeNumber(i, PR_FALSE);
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check if this is an integer attribute going away
IntegerAttributesInfo intInfo = GetIntegerInfo();
for (PRUint32 i = 0; i < intInfo.mIntegerCount; i++) {
if (aName == *intInfo.mIntegerInfo[i].mName) {
if (i + 1 < intInfo.mIntegerCount &&
aName == *intInfo.mIntegerInfo[i + 1].mName) {
// found a number-optional-number
intInfo.Reset(i + 1);
DidChangeNumber(i + 1, PR_FALSE);
}
intInfo.Reset(i);
DidChangeInteger(i, PR_FALSE);
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check if this is an angle attribute going away
AngleAttributesInfo angleInfo = GetAngleInfo();
for (PRUint32 i = 0; i < angleInfo.mAngleCount; i++) {
if (aName == *angleInfo.mAngleInfo[i].mName) {
angleInfo.Reset(i);
DidChangeAngle(i, PR_FALSE);
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check if this is a boolean attribute going away
BooleanAttributesInfo boolInfo = GetBooleanInfo();
for (PRUint32 i = 0; i < boolInfo.mBooleanCount; i++) {
if (aName == *boolInfo.mBooleanInfo[i].mName) {
boolInfo.Reset(i);
DidChangeBoolean(i, PR_FALSE);
foundMatch = PR_TRUE;
}
}
}
if (!foundMatch) {
// Check if this is an enum attribute going away
EnumAttributesInfo enumInfo = GetEnumInfo();
for (PRUint32 i = 0; i < enumInfo.mEnumCount; i++) {
if (aName == *enumInfo.mEnumInfo[i].mName) {
enumInfo.Reset(i);
DidChangeEnum(i, PR_FALSE);
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Check if this is a nsViewBox attribute going away
if (aName == nsGkAtoms::viewBox) {
nsSVGViewBox* viewBox = GetViewBox();
if (viewBox) {
viewBox->Init();
DidChangeViewBox(PR_FALSE);
foundMatch = PR_TRUE;
}
// Check if this is a preserveAspectRatio attribute going away
} else if (aName == nsGkAtoms::preserveAspectRatio) {
nsSVGPreserveAspectRatio *preserveAspectRatio =
GetPreserveAspectRatio();
if (preserveAspectRatio) {
preserveAspectRatio->Init();
DidChangePreserveAspectRatio(PR_FALSE);
foundMatch = PR_TRUE;
}
}
}
}
if (!foundMatch) {
// Check if this is a string attribute going away
StringAttributesInfo stringInfo = GetStringInfo();
for (PRUint32 i = 0; i < stringInfo.mStringCount; i++) {
if (aNamespaceID == stringInfo.mStringInfo[i].mNamespaceID &&
aName == *stringInfo.mStringInfo[i].mName) {
stringInfo.Reset(i);
DidChangeString(i);
foundMatch = PR_TRUE;
break;
}
}
}
if (!foundMatch) {
// Now check for one of the old style basetypes going away
nsCOMPtr<nsISVGValue> svg_value = GetMappedAttribute(aNamespaceID, aName);
if (svg_value) {
mSuppressNotification = PR_TRUE;
ResetOldStyleBaseType(svg_value);
mSuppressNotification = PR_FALSE;
}
}
return nsSVGElementBase::UnsetAttr(aNamespaceID, aName, aNotify);
}
void DCM_ATTRIBUTE_GROUP_CLASS::merge(DCM_ATTRIBUTE_GROUP_CLASS *mergeDicomObject_ptr)
// DESCRIPTION : Merge the given dicom object into "this".
// PRECONDITIONS :
// POSTCONDITIONS :
// EXCEPTIONS :
// NOTES : The merge attributes can overwrite "this" attributes.
//<<===========================================================================
{
// check if we are trying to merge this into this
if (mergeDicomObject_ptr == this)
{
if (loggerM_ptr)
{
loggerM_ptr->text(LOG_DEBUG, 1, "Trying to merge into same object - doing nothing");
}
// don't do anything
return;
}
// merge given object into this
// clean up any attribute
if (loggerM_ptr)
{
loggerM_ptr->text(LOG_DEBUG, 1, "Merge attribute count: %d", mergeDicomObject_ptr->GetNrAttributes());
}
while (mergeDicomObject_ptr->GetNrAttributes())
{
// get next merge attribute and remove it from source
DCM_ATTRIBUTE_CLASS *mergeAttribute_ptr = mergeDicomObject_ptr->GetAttribute(0);
mergeDicomObject_ptr->DeleteAttributeIndex(0);
if (loggerM_ptr)
{
loggerM_ptr->text(LOG_DEBUG, 1, "Merge attribute is (%04X,%04X)", mergeAttribute_ptr->GetGroup(), mergeAttribute_ptr->GetElement());
}
if(!mergeAttribute_ptr->IsPresent())
{
DeleteAttribute(mergeAttribute_ptr->GetMappedGroup(), mergeAttribute_ptr->GetMappedElement());
continue;
}
DCM_ATTRIBUTE_CLASS *attribute_ptr = GetMappedAttribute(mergeAttribute_ptr->GetMappedGroup(), mergeAttribute_ptr->GetMappedElement(), true);
if (attribute_ptr != NULL)
{
if (loggerM_ptr)
{
loggerM_ptr->text(LOG_DEBUG, 1, "GetMappedAttribute returns (%04X,%04X)", attribute_ptr->GetGroup(), attribute_ptr->GetElement());
}
// check VR of the merge attribute for SQ
if (mergeAttribute_ptr->GetVR() == ATTR_VR_SQ)
{
if (loggerM_ptr)
{
loggerM_ptr->text(LOG_DEBUG, 1, "Merge attribute (%04X,%04X) is SQ", mergeAttribute_ptr->GetGroup(), mergeAttribute_ptr->GetElement());
}
// check VR of matching attribute in destination
if (attribute_ptr->GetVR() != ATTR_VR_SQ)
{
if (loggerM_ptr)
{
loggerM_ptr->text(LOG_DEBUG, 1, "Destination attribute (%04X,%04X) is not SQ", attribute_ptr->GetGroup(), attribute_ptr->GetElement());
loggerM_ptr->text(LOG_DEBUG, 1, "Replacing destination attribute by merge SQ attribute - (%04X,%04X)", mergeAttribute_ptr->GetGroup(), mergeAttribute_ptr->GetElement());
}
// source to destination VRs are different
// overwrite destination with source
DeleteMappedAttributeIndex(mergeAttribute_ptr->GetMappedGroup(), mergeAttribute_ptr->GetMappedElement());
// copy merge attribute to destination
addAttribute(mergeAttribute_ptr);
}
else // destination attribute is a SQ
{
if (loggerM_ptr)
{
loggerM_ptr->text(LOG_DEBUG, 1, "Destination attribute (%04X,%04X) is SQ", attribute_ptr->GetGroup(), attribute_ptr->GetElement());
}
// check if destination SQ is empty
if (attribute_ptr->GetNrValues() == 0)
{
loggerM_ptr->text(LOG_DEBUG, 1, "Destination attribute has no items");
// check if there are items in the source
if (mergeAttribute_ptr->GetNrValues() != 0)
{
// allocate new SQ value for destination
DCM_VALUE_SQ_CLASS *sqValue_ptr = new DCM_VALUE_SQ_CLASS(UNDEFINED_LENGTH);
// add SQ value to destination
attribute_ptr->addSqValue(sqValue_ptr);
// copy items from source to destination
sqValue_ptr->merge(mergeAttribute_ptr);
}
}
else if (attribute_ptr->GetNrValues() == 1)
{
// sequence contains items
DCM_VALUE_SQ_CLASS *sqValue_ptr = (DCM_VALUE_SQ_CLASS*) attribute_ptr->GetValue(0);
// copy items from source to destination
sqValue_ptr->merge(mergeAttribute_ptr);
}
}
}
else
{
// delete original attribute
DeleteMappedAttributeIndex(mergeAttribute_ptr->GetMappedGroup(), mergeAttribute_ptr->GetMappedElement());
// copy merge attribute from source to destination
addAttribute(mergeAttribute_ptr);
if (loggerM_ptr)
{
loggerM_ptr->text(LOG_DEBUG, 1, "Replacing destination attribute by merge attribute - (%04X,%04X)", mergeAttribute_ptr->GetGroup(), mergeAttribute_ptr->GetElement());
}
}
}
else
{
// no matching attribute found in destination
// simply copy merge attribute from source is destination
addAttribute(mergeAttribute_ptr);
if (loggerM_ptr)
{
loggerM_ptr->text(LOG_DEBUG, 1, "Adding attribute for first time - (%04X,%04X)", mergeAttribute_ptr->GetGroup(), mergeAttribute_ptr->GetElement());
}
}
}
}
