void
nsAttrValue::Reset()
{
switch(BaseType()) {
case eStringBase:
{
nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
if (str) {
str->Release();
}
break;
}
case eOtherBase:
{
EnsureEmptyMiscContainer();
delete GetMiscContainer();
break;
}
case eAtomBase:
{
nsIAtom* atom = GetAtomValue();
NS_RELEASE(atom);
break;
}
case eIntegerBase:
{
break;
}
}
mBits = 0;
}
PRBool
nsAttrValue::EnsureEmptyAtomArray()
{
if (Type() == eAtomArray) {
ResetMiscAtomOrString();
GetAtomArrayValue()->Clear();
return PR_TRUE;
}
if (!EnsureEmptyMiscContainer()) {
// should already be reset
return PR_FALSE;
}
AtomArray* array = new AtomArray;
if (!array) {
Reset();
return PR_FALSE;
}
MiscContainer* cont = GetMiscContainer();
cont->mAtomArray = array;
cont->mType = eAtomArray;
return PR_TRUE;
}
void
nsAttrValue::SetTo(const nsIntMargin& aValue)
{
if (EnsureEmptyMiscContainer()) {
MiscContainer* cont = GetMiscContainer();
cont->mIntMargin = new nsIntMargin(aValue);
cont->mType = eIntMarginValue;
}
}
void
nsAttrValue::SetTo(nsISVGValue* aValue)
{
if (EnsureEmptyMiscContainer()) {
MiscContainer* cont = GetMiscContainer();
NS_ADDREF(cont->mSVGValue = aValue);
cont->mType = eSVGValue;
}
}
void
nsAttrValue::SetTo(nsICSSStyleRule* aValue)
{
if (EnsureEmptyMiscContainer()) {
MiscContainer* cont = GetMiscContainer();
NS_ADDREF(cont->mCSSStyleRule = aValue);
cont->mType = eCSSStyleRule;
}
}
void
nsAttrValue::SetTo(css::StyleRule* aValue, const nsAString* aSerialized)
{
if (EnsureEmptyMiscContainer()) {
MiscContainer* cont = GetMiscContainer();
NS_ADDREF(cont->mCSSStyleRule = aValue);
cont->mType = eCSSStyleRule;
SetMiscAtomOrString(aSerialized);
}
}
PRBool
nsAttrValue::ParseColor(const nsAString& aString, nsIDocument* aDocument)
{
nsAutoString colorStr(aString);
colorStr.CompressWhitespace(PR_TRUE, PR_TRUE);
if (colorStr.IsEmpty()) {
Reset();
return PR_FALSE;
}
nscolor color;
// No color names begin with a '#', but numerical colors do so
// it is a very common first char
if ((colorStr.CharAt(0) != '#') && NS_ColorNameToRGB(colorStr, &color)) {
SetTo(colorStr);
return PR_TRUE;
}
// Check if we are in compatibility mode
if (aDocument->GetCompatibilityMode() == eCompatibility_NavQuirks) {
NS_LooseHexToRGB(colorStr, &color);
}
else {
if (colorStr.First() != '#') {
Reset();
return PR_FALSE;
}
colorStr.Cut(0, 1);
if (!NS_HexToRGB(colorStr, &color)) {
Reset();
return PR_FALSE;
}
}
PRInt32 colAsInt = static_cast<PRInt32>(color);
PRInt32 tmp = colAsInt * NS_ATTRVALUE_INTEGERTYPE_MULTIPLIER;
if (tmp / NS_ATTRVALUE_INTEGERTYPE_MULTIPLIER == colAsInt) {
ResetIfSet();
SetIntValueAndType(colAsInt, eColor);
}
else if (EnsureEmptyMiscContainer()) {
MiscContainer* cont = GetMiscContainer();
cont->mColor = color;
cont->mType = eColor;
}
return PR_TRUE;
}
PRBool
nsAttrValue::ParseIntMarginValue(const nsAString& aString)
{
ResetIfSet();
nsIntMargin margins;
if (!nsContentUtils::ParseIntMarginValue(aString, margins))
return PR_FALSE;
if (EnsureEmptyMiscContainer()) {
MiscContainer* cont = GetMiscContainer();
cont->mIntMargin = new nsIntMargin(margins);
cont->mType = eIntMarginValue;
SetMiscAtomOrString(&aString);
return PR_TRUE;
}
return PR_FALSE;
}
void
nsAttrValue::SetColorValue(nscolor aColor, const nsAString& aString)
{
nsStringBuffer* buf = GetStringBuffer(aString);
if (!buf) {
return;
}
if (!EnsureEmptyMiscContainer()) {
buf->Release();
return;
}
MiscContainer* cont = GetMiscContainer();
cont->mColor = aColor;
cont->mType = eColor;
// Save the literal string we were passed for round-tripping.
cont->mStringBits = reinterpret_cast<PtrBits>(buf) | eStringBase;
}
PRBool nsAttrValue::ParseDoubleValue(const nsAString& aString)
{
ResetIfSet();
PRInt32 ec;
double val = PromiseFlatString(aString).ToDouble(&ec);
if (NS_FAILED(ec)) {
return PR_FALSE;
}
if (EnsureEmptyMiscContainer()) {
MiscContainer* cont = GetMiscContainer();
cont->mDoubleValue = val;
cont->mType = eDoubleValue;
nsAutoString serializedFloat;
serializedFloat.AppendFloat(val);
SetMiscAtomOrString(serializedFloat.Equals(aString) ? nsnull : &aString);
return PR_TRUE;
}
return PR_FALSE;
}
void
nsAttrValue::SetIntValueAndType(PRInt32 aValue, ValueType aType,
const nsAString* aStringValue)
{
if (aStringValue || aValue > NS_ATTRVALUE_INTEGERTYPE_MAXVALUE ||
aValue < NS_ATTRVALUE_INTEGERTYPE_MINVALUE) {
if (EnsureEmptyMiscContainer()) {
MiscContainer* cont = GetMiscContainer();
switch (aType) {
case eInteger:
{
cont->mInteger = aValue;
break;
}
case ePercent:
{
cont->mPercent = aValue;
break;
}
case eEnum:
{
cont->mEnumValue = aValue;
break;
}
default:
{
NS_NOTREACHED("unknown integer type");
break;
}
}
cont->mType = aType;
SetMiscAtomOrString(aStringValue);
}
} else {
NS_ASSERTION(!mBits, "Reset before calling SetIntValueAndType!");
mBits = (aValue * NS_ATTRVALUE_INTEGERTYPE_MULTIPLIER) | aType;
}
}
void
nsAttrValue::SetTo(const nsAttrValue& aOther)
{
switch (aOther.BaseType()) {
case eStringBase:
{
ResetIfSet();
nsStringBuffer* str = static_cast<nsStringBuffer*>(aOther.GetPtr());
if (str) {
str->AddRef();
SetPtrValueAndType(str, eStringBase);
}
#ifdef TAINTED
if(aOther.isTainted()==1){
mTainted=1;
mJSStr=aOther.mJSStr;
}
#endif
return;
}
case eOtherBase:
{
break;
}
case eAtomBase:
{
ResetIfSet();
nsIAtom* atom = aOther.GetAtomValue();
NS_ADDREF(atom);
SetPtrValueAndType(atom, eAtomBase);
return;
}
case eIntegerBase:
{
ResetIfSet();
mBits = aOther.mBits;
return;
}
}
MiscContainer* otherCont = aOther.GetMiscContainer();
if (!EnsureEmptyMiscContainer()) {
return;
}
MiscContainer* cont = GetMiscContainer();
switch (otherCont->mType) {
case eInteger:
{
cont->mInteger = otherCont->mInteger;
break;
}
case eEnum:
{
cont->mEnumValue = otherCont->mEnumValue;
break;
}
case ePercent:
{
cont->mPercent = otherCont->mPercent;
break;
}
case eColor:
{
cont->mColor = otherCont->mColor;
break;
}
case eCSSStyleRule:
{
NS_ADDREF(cont->mCSSStyleRule = otherCont->mCSSStyleRule);
break;
}
case eAtomArray:
{
if (!EnsureEmptyAtomArray() ||
!GetAtomArrayValue()->AppendElements(*otherCont->mAtomArray)) {
Reset();
return;
}
break;
}
case eSVGValue:
{
NS_ADDREF(cont->mSVGValue = otherCont->mSVGValue);
break;
}
case eDoubleValue:
{
cont->mDoubleValue = otherCont->mDoubleValue;
break;
}
case eIntMarginValue:
{
if (otherCont->mIntMargin)
cont->mIntMargin = new nsIntMargin(*otherCont->mIntMargin);
break;
}
default:
{
NS_NOTREACHED("unknown type stored in MiscContainer");
break;
}
}
void* otherPtr = MISC_STR_PTR(otherCont);
if (otherPtr) {
if (static_cast<ValueBaseType>(otherCont->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) ==
eStringBase) {
static_cast<nsStringBuffer*>(otherPtr)->AddRef();
} else {
static_cast<nsIAtom*>(otherPtr)->AddRef();
}
cont->mStringBits = otherCont->mStringBits;
}
// Note, set mType after switch-case, otherwise EnsureEmptyAtomArray doesn't
// work correctly.
cont->mType = otherCont->mType;
}
void
nsAttrValue::SetTo(const nsAttrValue& aOther)
{
switch (aOther.BaseType()) {
case eStringBase:
{
ResetIfSet();
nsStringBuffer* str = static_cast<nsStringBuffer*>(aOther.GetPtr());
if (str) {
str->AddRef();
SetPtrValueAndType(str, eStringBase);
}
return;
}
case eOtherBase:
{
break;
}
case eAtomBase:
{
ResetIfSet();
nsIAtom* atom = aOther.GetAtomValue();
NS_ADDREF(atom);
SetPtrValueAndType(atom, eAtomBase);
return;
}
case eIntegerBase:
{
ResetIfSet();
mBits = aOther.mBits;
return;
}
}
MiscContainer* otherCont = aOther.GetMiscContainer();
switch (otherCont->mType) {
case eColor:
{
if (EnsureEmptyMiscContainer()) {
MiscContainer* cont = GetMiscContainer();
cont->mColor = otherCont->mColor;
cont->mType = eColor;
}
break;
}
case eCSSStyleRule:
{
SetTo(otherCont->mCSSStyleRule);
break;
}
case eAtomArray:
{
if (!EnsureEmptyAtomArray() ||
!GetAtomArrayValue()->AppendObjects(*otherCont->mAtomArray)) {
Reset();
}
break;
}
#ifdef MOZ_SVG
case eSVGValue:
{
SetTo(otherCont->mSVGValue);
}
#endif
default:
{
NS_NOTREACHED("unknown type stored in MiscContainer");
break;
}
}
}
