void DOMSVGStringList::IndexedGetter(uint32_t aIndex, bool& aFound,
nsAString& aRetval) {
aFound = aIndex < InternalList().Length();
if (aFound) {
aRetval = InternalList()[aIndex];
}
}
NS_IMETHODIMP
DOMSVGPathSegList::InsertItemBefore(nsIDOMSVGPathSeg *aNewItem,
PRUint32 aIndex,
nsIDOMSVGPathSeg **_retval)
{
*_retval = nsnull;
if (IsAnimValList()) {
return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
}
PRUint32 internalIndex;
if (aIndex < Length()) {
internalIndex = mItems[aIndex].mInternalDataIndex;
} else {
aIndex = Length();
internalIndex = InternalList().mData.Length();
}
if (aIndex >= DOMSVGPathSeg::MaxListIndex()) {
return NS_ERROR_DOM_INDEX_SIZE_ERR;
}
nsCOMPtr<DOMSVGPathSeg> domItem = do_QueryInterface(aNewItem);
if (!domItem) {
return NS_ERROR_DOM_SVG_WRONG_TYPE_ERR;
}
if (domItem->HasOwner()) {
domItem = domItem->Clone(); // must do this before changing anything!
}
PRUint32 argCount = SVGPathSegUtils::ArgCountForType(domItem->Type());
// Ensure we have enough memory so we can avoid complex error handling below:
if (!mItems.SetCapacity(mItems.Length() + 1) ||
!InternalList().mData.SetCapacity(InternalList().mData.Length() + 1 + argCount)) {
return NS_ERROR_OUT_OF_MEMORY;
}
// Now that we know we're inserting, keep animVal list in sync as necessary.
MaybeInsertNullInAnimValListAt(aIndex, internalIndex, argCount);
float segAsRaw[1 + NS_SVG_PATH_SEG_MAX_ARGS];
domItem->ToSVGPathSegEncodedData(segAsRaw);
InternalList().mData.InsertElementsAt(internalIndex, segAsRaw, 1 + argCount);
mItems.InsertElementAt(aIndex, ItemProxy(domItem.get(), internalIndex));
// This MUST come after the insertion into InternalList(), or else under the
// insertion into InternalList() the values read from domItem would be bad
// data from InternalList() itself!:
domItem->InsertingIntoList(this, aIndex, IsAnimValList());
UpdateListIndicesFromIndex(aIndex + 1, argCount + 1);
Element()->DidChangePathSegList(true);
if (AttrIsAnimating()) {
Element()->AnimationNeedsResample();
}
*_retval = domItem.forget().get();
return NS_OK;
}
NS_IMETHODIMP
DOMSVGStringList::InsertItemBefore(const nsAString & newItem,
PRUint32 index,
nsAString & _retval)
{
if (newItem.IsEmpty()) { // takes care of DOMStringIsNull too
return NS_ERROR_DOM_SVG_INVALID_VALUE_ERR;
}
index = NS_MIN(index, InternalList().Length());
// Ensure we have enough memory so we can avoid complex error handling below:
if (!InternalList().SetCapacity(InternalList().Length() + 1)) {
return NS_ERROR_OUT_OF_MEMORY;
}
nsAttrValue emptyOrOldValue =
mElement->WillChangeStringList(mIsConditionalProcessingAttribute,
mAttrEnum);
InternalList().InsertItem(index, newItem);
mElement->DidChangeStringList(mIsConditionalProcessingAttribute, mAttrEnum,
emptyOrOldValue);
_retval = newItem;
return NS_OK;
}
void DOMSVGStringList::Initialize(const nsAString& aNewItem, nsAString& aRetval,
ErrorResult& aRv) {
if (InternalList().IsExplicitlySet()) {
InternalList().Clear();
}
InsertItemBefore(aNewItem, 0, aRetval, aRv);
}
already_AddRefed<DOMSVGPathSeg>
DOMSVGPathSegList::InsertItemBefore(DOMSVGPathSeg& aNewItem,
uint32_t aIndex,
ErrorResult& aError)
{
if (IsAnimValList()) {
aError.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
return nullptr;
}
uint32_t internalIndex;
if (aIndex < LengthNoFlush()) {
internalIndex = mItems[aIndex].mInternalDataIndex;
} else {
aIndex = LengthNoFlush();
internalIndex = InternalList().mData.Length();
}
if (aIndex >= DOMSVGPathSeg::MaxListIndex()) {
aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return nullptr;
}
nsRefPtr<DOMSVGPathSeg> domItem = &aNewItem;
if (domItem->HasOwner()) {
domItem = domItem->Clone(); // must do this before changing anything!
}
uint32_t argCount = SVGPathSegUtils::ArgCountForType(domItem->Type());
// Ensure we have enough memory so we can avoid complex error handling below:
if (!mItems.SetCapacity(mItems.Length() + 1) ||
!InternalList().mData.SetCapacity(InternalList().mData.Length() + 1 + argCount)) {
aError.Throw(NS_ERROR_OUT_OF_MEMORY);
return nullptr;
}
nsAttrValue emptyOrOldValue = Element()->WillChangePathSegList();
// Now that we know we're inserting, keep animVal list in sync as necessary.
MaybeInsertNullInAnimValListAt(aIndex, internalIndex, argCount);
float segAsRaw[1 + NS_SVG_PATH_SEG_MAX_ARGS];
domItem->ToSVGPathSegEncodedData(segAsRaw);
InternalList().mData.InsertElementsAt(internalIndex, segAsRaw, 1 + argCount);
mItems.InsertElementAt(aIndex, ItemProxy(domItem.get(), internalIndex));
// This MUST come after the insertion into InternalList(), or else under the
// insertion into InternalList() the values read from domItem would be bad
// data from InternalList() itself!:
domItem->InsertingIntoList(this, aIndex, IsAnimValList());
UpdateListIndicesFromIndex(aIndex + 1, argCount + 1);
Element()->DidChangePathSegList(emptyOrOldValue);
if (AttrIsAnimating()) {
Element()->AnimationNeedsResample();
}
return domItem.forget();
}
void
DOMSVGStringList::Clear()
{
if (InternalList().IsExplicitlySet()) {
AutoChangeStringListNotifier notifier(this);
InternalList().Clear();
}
}
NS_IMETHODIMP
DOMSVGStringList::Initialize(const nsAString & newItem, nsAString & _retval)
{
if (InternalList().IsExplicitlySet()) {
InternalList().Clear();
}
return InsertItemBefore(newItem, 0, _retval);
}
NS_IMETHODIMP
DOMSVGStringList::GetItem(PRUint32 index,
nsAString & _retval)
{
if (index >= InternalList().Length()) {
return NS_ERROR_DOM_INDEX_SIZE_ERR;
}
_retval = InternalList()[index];
return NS_OK;
}
void DOMSVGStringList::RemoveItem(uint32_t aIndex, nsAString& aRetval,
ErrorResult& aRv) {
if (aIndex >= InternalList().Length()) {
aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return;
}
AutoChangeStringListNotifier notifier(this);
InternalList().RemoveItem(aIndex);
}
NS_IMETHODIMP
DOMSVGStringList::Clear()
{
if (InternalList().IsExplicitlySet()) {
InternalList().Clear();
mElement->DidChangeStringList(mIsConditionalProcessingAttribute,
mAttrEnum);
}
return NS_OK;
}
already_AddRefed<nsISVGPoint>
DOMSVGPointList::InsertItemBefore(nsISVGPoint& aNewItem, uint32_t aIndex,
ErrorResult& aError)
{
if (IsAnimValList()) {
aError.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
return nullptr;
}
aIndex = std::min(aIndex, LengthNoFlush());
if (aIndex >= nsISVGPoint::MaxListIndex()) {
aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return nullptr;
}
nsCOMPtr<nsISVGPoint> domItem = &aNewItem;
if (domItem->HasOwner() || domItem->IsReadonly() ||
domItem->IsTranslatePoint()) {
domItem = domItem->Copy(); // must do this before changing anything!
}
// Ensure we have enough memory so we can avoid complex error handling below:
if (!mItems.SetCapacity(mItems.Length() + 1, fallible) ||
!InternalList().SetCapacity(InternalList().Length() + 1)) {
aError.Throw(NS_ERROR_OUT_OF_MEMORY);
return nullptr;
}
if (AnimListMirrorsBaseList()) {
DOMSVGPointList *animVal =
GetDOMWrapperIfExists(InternalAList().GetAnimValKey());
MOZ_ASSERT(animVal, "animVal must be a valid pointer");
if (!animVal->mItems.SetCapacity(
animVal->mItems.Length() + 1, fallible)) {
aError.Throw(NS_ERROR_OUT_OF_MEMORY);
return nullptr;
}
}
AutoChangePointListNotifier notifier(this);
// Now that we know we're inserting, keep animVal list in sync as necessary.
MaybeInsertNullInAnimValListAt(aIndex);
InternalList().InsertItem(aIndex, domItem->ToSVGPoint());
MOZ_ALWAYS_TRUE(mItems.InsertElementAt(aIndex, domItem, fallible));
// This MUST come after the insertion into InternalList(), or else under the
// insertion into InternalList() the values read from domItem would be bad
// data from InternalList() itself!:
domItem->InsertingIntoList(this, aIndex, IsAnimValList());
UpdateListIndicesFromIndex(mItems, aIndex + 1);
return domItem.forget();
}
NS_IMETHODIMP
DOMSVGStringList::Clear()
{
if (InternalList().IsExplicitlySet()) {
nsAttrValue emptyOrOldValue =
mElement->WillChangeStringList(mIsConditionalProcessingAttribute,
mAttrEnum);
InternalList().Clear();
mElement->DidChangeStringList(mIsConditionalProcessingAttribute,
mAttrEnum, emptyOrOldValue);
}
return NS_OK;
}
NS_IMETHODIMP
DOMSVGStringList::RemoveItem(PRUint32 index,
nsAString & _retval)
{
if (index >= InternalList().Length()) {
return NS_ERROR_DOM_INDEX_SIZE_ERR;
}
InternalList().RemoveItem(index);
mElement->DidChangeStringList(mIsConditionalProcessingAttribute, mAttrEnum);
return NS_OK;
}
already_AddRefed<nsIDOMSVGPoint>
DOMSVGPointList::InsertItemBefore(nsIDOMSVGPoint *aNewItem, uint32_t aIndex,
ErrorResult& aError)
{
if (IsAnimValList()) {
aError.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
return nullptr;
}
aIndex = NS_MIN(aIndex, LengthNoFlush());
if (aIndex >= DOMSVGPoint::MaxListIndex()) {
aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return nullptr;
}
nsCOMPtr<DOMSVGPoint> domItem = do_QueryInterface(aNewItem);
if (!domItem) {
aError.Throw(NS_ERROR_DOM_SVG_WRONG_TYPE_ERR);
return nullptr;
}
if (domItem->HasOwner() || domItem->IsReadonly()) {
domItem = domItem->Clone(); // must do this before changing anything!
}
// Ensure we have enough memory so we can avoid complex error handling below:
if (!mItems.SetCapacity(mItems.Length() + 1) ||
!InternalList().SetCapacity(InternalList().Length() + 1)) {
aError.Throw(NS_ERROR_OUT_OF_MEMORY);
return nullptr;
}
nsAttrValue emptyOrOldValue = Element()->WillChangePointList();
// Now that we know we're inserting, keep animVal list in sync as necessary.
MaybeInsertNullInAnimValListAt(aIndex);
InternalList().InsertItem(aIndex, domItem->ToSVGPoint());
mItems.InsertElementAt(aIndex, domItem.get());
// This MUST come after the insertion into InternalList(), or else under the
// insertion into InternalList() the values read from domItem would be bad
// data from InternalList() itself!:
domItem->InsertingIntoList(this, aIndex, IsAnimValList());
UpdateListIndicesFromIndex(mItems, aIndex + 1);
Element()->DidChangePointList(emptyOrOldValue);
if (AttrIsAnimating()) {
Element()->AnimationNeedsResample();
}
return domItem.forget();
}
NS_IMETHODIMP
DOMSVGNumberList::InsertItemBefore(nsIDOMSVGNumber *newItem,
PRUint32 index,
nsIDOMSVGNumber **_retval)
{
*_retval = nsnull;
if (IsAnimValList()) {
return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
}
index = NS_MIN(index, Length());
if (index >= DOMSVGNumber::MaxListIndex()) {
return NS_ERROR_DOM_INDEX_SIZE_ERR;
}
nsCOMPtr<DOMSVGNumber> domItem = do_QueryInterface(newItem);
if (!domItem) {
return NS_ERROR_DOM_SVG_WRONG_TYPE_ERR;
}
if (domItem->HasOwner()) {
domItem = domItem->Clone(); // must do this before changing anything!
}
// Ensure we have enough memory so we can avoid complex error handling below:
if (!mItems.SetCapacity(mItems.Length() + 1) ||
!InternalList().SetCapacity(InternalList().Length() + 1)) {
return NS_ERROR_OUT_OF_MEMORY;
}
// Now that we know we're inserting, keep animVal list in sync as necessary.
MaybeInsertNullInAnimValListAt(index);
InternalList().InsertItem(index, domItem->ToSVGNumber());
mItems.InsertElementAt(index, domItem.get());
// This MUST come after the insertion into InternalList(), or else under the
// insertion into InternalList() the values read from domItem would be bad
// data from InternalList() itself!:
domItem->InsertingIntoList(this, AttrEnum(), index, IsAnimValList());
UpdateListIndicesFromIndex(mItems, index + 1);
Element()->DidChangeNumberList(AttrEnum(), PR_TRUE);
#ifdef MOZ_SMIL
if (mAList->IsAnimating()) {
Element()->AnimationNeedsResample();
}
#endif
*_retval = domItem.forget().get();
return NS_OK;
}
void DOMSVGStringList::ReplaceItem(const nsAString& aNewItem, uint32_t aIndex,
nsAString& aRetval, ErrorResult& aRv) {
if (aNewItem.IsEmpty()) {
aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
return;
}
if (aIndex >= InternalList().Length()) {
aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return;
}
aRetval = InternalList()[aIndex];
AutoChangeStringListNotifier notifier(this);
InternalList().ReplaceItem(aIndex, aNewItem);
}
NS_IMETHODIMP
DOMSVGPointList::Clear()
{
if (IsAnimValList()) {
return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
}
if (Length() > 0) {
// DOM list items that are to be removed must be removed before we change
// the internal list, otherwise they wouldn't be able to copy their
// internal counterparts' values!
InternalListWillChangeTo(SVGPointList()); // clears mItems
if (!AttrIsAnimating()) {
// The anim val list is in sync with the base val list
DOMSVGPointList *animList =
GetDOMWrapperIfExists(InternalAList().GetAnimValKey());
if (animList) {
animList->InternalListWillChangeTo(SVGPointList()); // clears its mItems
}
}
InternalList().Clear();
Element()->DidChangePointList(true);
if (AttrIsAnimating()) {
Element()->AnimationNeedsResample();
}
}
return NS_OK;
}
/* nsIDOMSVGTransform consolidate (); */
NS_IMETHODIMP
DOMSVGTransformList::Consolidate(nsIDOMSVGTransform **_retval)
{
*_retval = nsnull;
if (IsAnimValList()) {
return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
}
if (Length() == 0)
return NS_OK;
// Note that SVG 1.1 says, "The consolidation operation creates new
// SVGTransform object as the first and only item in the list" hence, even if
// Length() == 1 we can't return that one item (after making it a matrix
// type). We must orphan the existing item and then make a new one.
// First calculate our matrix
gfxMatrix mx = InternalList().GetConsolidationMatrix();
// Then orphan the existing items
Clear();
// And append the new transform
nsRefPtr<DOMSVGTransform> transform = new DOMSVGTransform(mx);
return InsertItemBefore(transform, Length(), _retval);
}
already_AddRefed<SVGTransform>
DOMSVGTransformList::ReplaceItem(SVGTransform& newItem,
uint32_t index, ErrorResult& error)
{
if (IsAnimValList()) {
error.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
return nullptr;
}
if (index >= LengthNoFlush()) {
error.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return nullptr;
}
nsRefPtr<SVGTransform> domItem = &newItem;
if (newItem.HasOwner()) {
domItem = newItem.Clone(); // must do this before changing anything!
}
AutoChangeTransformListNotifier notifier(this);
if (mItems[index]) {
// Notify any existing DOM item of removal *before* modifying the lists so
// that the DOM item can copy the *old* value at its index:
mItems[index]->RemovingFromList();
}
InternalList()[index] = domItem->ToSVGTransform();
mItems[index] = domItem;
// This MUST come after the ToSVGPoint() call, otherwise that call
// would end up reading bad data from InternalList()!
domItem->InsertingIntoList(this, index, IsAnimValList());
return domItem.forget();
}
already_AddRefed<SVGTransform>
DOMSVGTransformList::Consolidate(ErrorResult& error)
{
if (IsAnimValList()) {
error.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
return nullptr;
}
if (LengthNoFlush() == 0) {
return nullptr;
}
// Note that SVG 1.1 says, "The consolidation operation creates new
// SVGTransform object as the first and only item in the list" hence, even if
// LengthNoFlush() == 1 we can't return that one item (after making it a
// matrix type). We must orphan the existing item and then make a new one.
// First calculate our matrix
gfxMatrix mx = InternalList().GetConsolidationMatrix();
// Then orphan the existing items
Clear(error);
MOZ_ASSERT(!error.Failed(), "How could this fail?");
// And append the new transform
nsRefPtr<SVGTransform> transform = new SVGTransform(mx);
return InsertItemBefore(*transform, LengthNoFlush(), error);
}
already_AddRefed<nsISVGPoint>
DOMSVGPointList::RemoveItem(uint32_t aIndex, ErrorResult& aError)
{
if (IsAnimValList()) {
aError.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
return nullptr;
}
if (aIndex >= LengthNoFlush()) {
aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return nullptr;
}
AutoChangePointListNotifier notifier(this);
// Now that we know we're removing, keep animVal list in sync as necessary.
// Do this *before* touching InternalList() so the removed item can get its
// internal value.
MaybeRemoveItemFromAnimValListAt(aIndex);
// We have to return the removed item, so get it, creating it if necessary:
RefPtr<nsISVGPoint> result = GetItemAt(aIndex);
// Notify the DOM item of removal *before* modifying the lists so that the
// DOM item can copy its *old* value:
mItems[aIndex]->RemovingFromList();
InternalList().RemoveItem(aIndex);
mItems.RemoveElementAt(aIndex);
UpdateListIndicesFromIndex(mItems, aIndex);
return result.forget();
}
void
DOMSVGPathSegList::Clear(ErrorResult& aError)
{
if (IsAnimValList()) {
aError.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
return;
}
if (LengthNoFlush() > 0) {
nsAttrValue emptyOrOldValue = Element()->WillChangePathSegList();
// DOM list items that are to be removed must be removed before we change
// the internal list, otherwise they wouldn't be able to copy their
// internal counterparts' values!
InternalListWillChangeTo(SVGPathData()); // clears mItems
if (!AttrIsAnimating()) {
// The anim val list is in sync with the base val list
DOMSVGPathSegList *animList =
GetDOMWrapperIfExists(InternalAList().GetAnimValKey());
if (animList) {
animList->InternalListWillChangeTo(SVGPathData()); // clears its mItems
}
}
InternalList().Clear();
Element()->DidChangePathSegList(emptyOrOldValue);
if (AttrIsAnimating()) {
Element()->AnimationNeedsResample();
}
}
}
void
DOMSVGPointList::Clear(ErrorResult& aError)
{
if (IsAnimValList()) {
aError.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
return;
}
if (LengthNoFlush() > 0) {
AutoChangePointListNotifier notifier(this);
// DOM list items that are to be removed must be removed before we change
// the internal list, otherwise they wouldn't be able to copy their
// internal counterparts' values!
InternalListWillChangeTo(SVGPointList()); // clears mItems
if (!AttrIsAnimating()) {
// The anim val list is in sync with the base val list
DOMSVGPointList *animList =
GetDOMWrapperIfExists(InternalAList().GetAnimValKey());
if (animList) {
animList->InternalListWillChangeTo(SVGPointList()); // clears its mItems
}
}
InternalList().Clear();
}
}
already_AddRefed<SVGTransform>
DOMSVGTransformList::InsertItemBefore(SVGTransform& newItem,
uint32_t index, ErrorResult& error)
{
if (IsAnimValList()) {
error.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
return nullptr;
}
index = std::min(index, LengthNoFlush());
if (index >= SVGTransform::MaxListIndex()) {
error.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return nullptr;
}
nsRefPtr<SVGTransform> domItem = &newItem;
if (newItem.HasOwner()) {
domItem = newItem.Clone(); // must do this before changing anything!
}
// Ensure we have enough memory so we can avoid complex error handling below:
if (!mItems.SetCapacity(mItems.Length() + 1) ||
!InternalList().SetCapacity(InternalList().Length() + 1)) {
error.Throw(NS_ERROR_OUT_OF_MEMORY);
return nullptr;
}
nsAttrValue emptyOrOldValue = Element()->WillChangeTransformList();
// Now that we know we're inserting, keep animVal list in sync as necessary.
MaybeInsertNullInAnimValListAt(index);
InternalList().InsertItem(index, domItem->ToSVGTransform());
mItems.InsertElementAt(index, domItem.get());
// This MUST come after the insertion into InternalList(), or else under the
// insertion into InternalList() the values read from domItem would be bad
// data from InternalList() itself!:
domItem->InsertingIntoList(this, index, IsAnimValList());
UpdateListIndicesFromIndex(mItems, index + 1);
Element()->DidChangeTransformList(emptyOrOldValue);
if (mAList->IsAnimating()) {
Element()->AnimationNeedsResample();
}
return domItem.forget();
}
NS_IMETHODIMP
DOMSVGStringList::RemoveItem(uint32_t index,
nsAString & _retval)
{
if (index >= InternalList().Length()) {
return NS_ERROR_DOM_INDEX_SIZE_ERR;
}
nsAttrValue emptyOrOldValue =
mElement->WillChangeStringList(mIsConditionalProcessingAttribute,
mAttrEnum);
InternalList().RemoveItem(index);
mElement->DidChangeStringList(mIsConditionalProcessingAttribute, mAttrEnum,
emptyOrOldValue);
return NS_OK;
}
already_AddRefed<DOMSVGPathSeg>
DOMSVGPathSegList::RemoveItem(uint32_t aIndex,
ErrorResult& aError)
{
if (IsAnimValList()) {
aError.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
return nullptr;
}
if (aIndex >= LengthNoFlush()) {
aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return nullptr;
}
// We have to return the removed item, so make sure it exists:
EnsureItemAt(aIndex);
nsAttrValue emptyOrOldValue = Element()->WillChangePathSegList();
// Notify the DOM item of removal *before* modifying the lists so that the
// DOM item can copy its *old* value:
ItemAt(aIndex)->RemovingFromList();
nsRefPtr<DOMSVGPathSeg> result = ItemAt(aIndex);
uint32_t internalIndex = mItems[aIndex].mInternalDataIndex;
uint32_t segType = SVGPathSegUtils::DecodeType(InternalList().mData[internalIndex]);
// NOTE: ArgCountForType returns a (small) unsigned value, but we're
// intentionally putting it in a signed value, because we're going to
// negate it, and you can't negate an unsigned value.
int32_t argCount = SVGPathSegUtils::ArgCountForType(segType);
// Now that we know we're removing, keep animVal list in sync as necessary.
// Do this *before* touching InternalList() so the removed item can get its
// internal value.
MaybeRemoveItemFromAnimValListAt(aIndex, argCount);
InternalList().mData.RemoveElementsAt(internalIndex, 1 + argCount);
mItems.RemoveElementAt(aIndex);
UpdateListIndicesFromIndex(aIndex, -(argCount + 1));
Element()->DidChangePathSegList(emptyOrOldValue);
if (AttrIsAnimating()) {
Element()->AnimationNeedsResample();
}
return result.forget();
}
NS_IMETHODIMP
DOMSVGStringList::ReplaceItem(const nsAString & newItem,
PRUint32 index,
nsAString & _retval)
{
if (newItem.IsEmpty()) { // takes care of DOMStringIsNull too
return NS_ERROR_DOM_SVG_INVALID_VALUE_ERR;
}
if (index >= InternalList().Length()) {
return NS_ERROR_DOM_INDEX_SIZE_ERR;
}
_retval = InternalList()[index];
InternalList().ReplaceItem(index, newItem);
mElement->DidChangeStringList(mIsConditionalProcessingAttribute, mAttrEnum);
return NS_OK;
}
NS_IMETHODIMP
DOMSVGStringList::InsertItemBefore(const nsAString & newItem,
PRUint32 index,
nsAString & _retval)
{
index = NS_MIN(index, InternalList().Length());
// Ensure we have enough memory so we can avoid complex error handling below:
if (!InternalList().SetCapacity(InternalList().Length() + 1)) {
return NS_ERROR_OUT_OF_MEMORY;
}
InternalList().InsertItem(index, newItem);
mElement->DidChangeStringList(mIsConditionalProcessingAttribute, mAttrEnum);
_retval = newItem;
return NS_OK;
}
NS_IMETHODIMP
DOMSVGLengthList::InsertItemBefore(nsIDOMSVGLength *newItem,
PRUint32 index,
nsIDOMSVGLength **_retval)
{
*_retval = nsnull;
if (IsAnimValList()) {
return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
}
nsCOMPtr<DOMSVGLength> domItem = do_QueryInterface(newItem);
if (!domItem) {
return NS_ERROR_DOM_SVG_WRONG_TYPE_ERR;
}
index = NS_MIN(index, Length());
SVGLength length = domItem->ToSVGLength(); // get before setting domItem
if (domItem->HasOwner()) {
domItem = new DOMSVGLength();
}
PRBool ok = !!InternalList().InsertItem(index, length);
if (!ok) {
return NS_ERROR_OUT_OF_MEMORY;
}
domItem->InsertingIntoList(this, AttrEnum(), index, IsAnimValList());
ok = !!mItems.InsertElementAt(index, domItem.get());
if (!ok) {
InternalList().RemoveItem(index);
return NS_ERROR_OUT_OF_MEMORY;
}
for (PRUint32 i = index + 1; i < Length(); ++i) {
if (mItems[i]) {
mItems[i]->UpdateListIndex(i);
}
}
Element()->DidChangeLengthList(AttrEnum(), PR_TRUE);
#ifdef MOZ_SMIL
if (mAList->IsAnimating()) {
Element()->AnimationNeedsResample();
}
#endif
*_retval = domItem.forget().get();
return NS_OK;
}
void DOMSVGStringList::InsertItemBefore(const nsAString& aNewItem,
uint32_t aIndex, nsAString& aRetval,
ErrorResult& aRv) {
if (aNewItem.IsEmpty()) {
aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
return;
}
aIndex = std::min(aIndex, InternalList().Length());
// Ensure we have enough memory so we can avoid complex error handling below:
if (!InternalList().SetCapacity(InternalList().Length() + 1)) {
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
return;
}
AutoChangeStringListNotifier notifier(this);
InternalList().InsertItem(aIndex, aNewItem);
aRetval = aNewItem;
}
