void DOMSVGPointList::Clear(ErrorResult& aError) { if (IsAnimValList()) { aError.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR); return; } if (LengthNoFlush() > 0) { nsAttrValue emptyOrOldValue = Element()->WillChangePointList(); // 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(emptyOrOldValue); if (AttrIsAnimating()) { Element()->AnimationNeedsResample(); } } }
NS_IMETHODIMP DOMSVGPathSegList::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(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(true); if (AttrIsAnimating()) { Element()->AnimationNeedsResample(); } } return NS_OK; }
void DOMSVGPathSegList:: MaybeInsertNullInAnimValListAt(uint32_t aIndex, uint32_t aInternalIndex, uint32_t aArgCountForItem) { NS_ABORT_IF_FALSE(!IsAnimValList(), "call from baseVal to animVal"); if (AttrIsAnimating()) { // animVal not a clone of baseVal return; } // The anim val list is in sync with the base val list DOMSVGPathSegList *animVal = GetDOMWrapperIfExists(InternalAList().GetAnimValKey()); if (!animVal) { // No animVal list wrapper return; } NS_ABORT_IF_FALSE(animVal->mItems.Length() == mItems.Length(), "animVal list not in sync!"); animVal->mItems.InsertElementAt(aIndex, ItemProxy(nullptr, aInternalIndex)); animVal->UpdateListIndicesFromIndex(aIndex + 1, 1 + aArgCountForItem); }
void DOMSVGPathSegList:: MaybeRemoveItemFromAnimValListAt(uint32_t aIndex, int32_t aArgCountForItem) { MOZ_ASSERT(!IsAnimValList(), "call from baseVal to animVal"); if (AttrIsAnimating()) { // animVal not a clone of baseVal return; } // This needs to be a strong reference; otherwise, the RemovingFromList call // below might drop the last reference to animVal before we're done with it. nsRefPtr<DOMSVGPathSegList> animVal = GetDOMWrapperIfExists(InternalAList().GetAnimValKey()); if (!animVal) { // No animVal list wrapper return; } MOZ_ASSERT(animVal->mItems.Length() == mItems.Length(), "animVal list not in sync!"); if (animVal->ItemAt(aIndex)) { animVal->ItemAt(aIndex)->RemovingFromList(); } animVal->mItems.RemoveElementAt(aIndex); animVal->UpdateListIndicesFromIndex(aIndex, -(1 + aArgCountForItem)); }
void DOMSVGPathSegList::Clear(ErrorResult& aError) { if (IsAnimValList()) { aError.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR); return; } if (LengthNoFlush() > 0) { AutoChangePathSegListNotifier 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(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(); } }
void DOMSVGPointList::MaybeInsertNullInAnimValListAt(uint32_t aIndex) { MOZ_ASSERT(!IsAnimValList(), "call from baseVal to animVal"); if (AttrIsAnimating()) { // animVal not a clone of baseVal return; } // The anim val list is in sync with the base val list DOMSVGPointList *animVal = GetDOMWrapperIfExists(InternalAList().GetAnimValKey()); if (!animVal) { // No animVal list wrapper return; } MOZ_ASSERT(animVal->mItems.Length() == mItems.Length(), "animVal list not in sync!"); MOZ_ALWAYS_TRUE(animVal->mItems.InsertElementAt(aIndex, nullptr, fallible)); UpdateListIndicesFromIndex(animVal->mItems, aIndex + 1); }
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; }
void DOMSVGPointList::MaybeInsertNullInAnimValListAt(uint32_t aIndex) { NS_ABORT_IF_FALSE(!IsAnimValList(), "call from baseVal to animVal"); if (AttrIsAnimating()) { // animVal not a clone of baseVal return; } // The anim val list is in sync with the base val list DOMSVGPointList *animVal = GetDOMWrapperIfExists(InternalAList().GetAnimValKey()); if (!animVal) { // No animVal list wrapper return; } NS_ABORT_IF_FALSE(animVal->mItems.Length() == mItems.Length(), "animVal list not in sync!"); animVal->mItems.InsertElementAt(aIndex, static_cast<nsISVGPoint*>(nullptr)); UpdateListIndicesFromIndex(animVal->mItems, aIndex + 1); }
void DOMSVGPathSegList:: MaybeRemoveItemFromAnimValListAt(PRUint32 aIndex, PRUint32 aArgCountForItem) { NS_ABORT_IF_FALSE(!IsAnimValList(), "call from baseVal to animVal"); if (AttrIsAnimating()) { // animVal not a clone of baseVal return; } DOMSVGPathSegList *animVal = GetDOMWrapperIfExists(InternalAList().GetAnimValKey()); if (!animVal) { // No animVal list wrapper return; } NS_ABORT_IF_FALSE(animVal->mItems.Length() == mItems.Length(), "animVal list not in sync!"); if (animVal->ItemAt(aIndex)) { animVal->ItemAt(aIndex)->RemovingFromList(); } animVal->mItems.RemoveElementAt(aIndex); animVal->UpdateListIndicesFromIndex(aIndex, -(1 + aArgCountForItem)); }
void DOMSVGPointList::MaybeRemoveItemFromAnimValListAt(uint32_t aIndex) { NS_ABORT_IF_FALSE(!IsAnimValList(), "call from baseVal to animVal"); if (AttrIsAnimating()) { // animVal not a clone of baseVal return; } // This needs to be a strong reference; otherwise, the RemovingFromList call // below might drop the last reference to animVal before we're done with it. nsRefPtr<DOMSVGPointList> animVal = GetDOMWrapperIfExists(InternalAList().GetAnimValKey()); if (!animVal) { // No animVal list wrapper return; } NS_ABORT_IF_FALSE(animVal->mItems.Length() == mItems.Length(), "animVal list not in sync!"); if (animVal->mItems[aIndex]) { animVal->mItems[aIndex]->RemovingFromList(); } animVal->mItems.RemoveElementAt(aIndex); UpdateListIndicesFromIndex(animVal->mItems, aIndex); }
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(); }
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 DOMSVGPointList::InsertItemBefore(nsIDOMSVGPoint *aNewItem, PRUint32 aIndex, nsIDOMSVGPoint **_retval) { *_retval = nsnull; if (IsAnimValList()) { return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR; } aIndex = NS_MIN(aIndex, Length()); if (aIndex >= DOMSVGPoint::MaxListIndex()) { return NS_ERROR_DOM_INDEX_SIZE_ERR; } nsCOMPtr<DOMSVGPoint> domItem = do_QueryInterface(aNewItem); if (!domItem) { return NS_ERROR_DOM_SVG_WRONG_TYPE_ERR; } 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)) { return NS_ERROR_OUT_OF_MEMORY; } // 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(PR_TRUE); #ifdef MOZ_SMIL if (AttrIsAnimating()) { Element()->AnimationNeedsResample(); } #endif *_retval = domItem.forget().get(); 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 DOMSVGPointList::ReplaceItem(nsIDOMSVGPoint *aNewItem, PRUint32 aIndex, nsIDOMSVGPoint **_retval) { *_retval = nsnull; if (IsAnimValList()) { return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR; } nsCOMPtr<DOMSVGPoint> domItem = do_QueryInterface(aNewItem); if (!domItem) { return NS_ERROR_DOM_SVG_WRONG_TYPE_ERR; } if (aIndex >= Length()) { return NS_ERROR_DOM_INDEX_SIZE_ERR; } if (domItem->HasOwner() || domItem->IsReadonly()) { domItem = domItem->Clone(); // must do this before changing anything! } if (mItems[aIndex]) { // 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[aIndex]->RemovingFromList(); } InternalList()[aIndex] = domItem->ToSVGPoint(); mItems[aIndex] = domItem; // This MUST come after the ToSVGPoint() call, otherwise that call // would end up reading bad data from InternalList()! domItem->InsertingIntoList(this, aIndex, IsAnimValList()); Element()->DidChangePointList(PR_TRUE); #ifdef MOZ_SMIL if (AttrIsAnimating()) { Element()->AnimationNeedsResample(); } #endif NS_ADDREF(*_retval = domItem.get()); return NS_OK; }
NS_IMETHODIMP DOMSVGPathSegList::RemoveItem(PRUint32 aIndex, nsIDOMSVGPathSeg **_retval) { *_retval = nsnull; if (IsAnimValList()) { return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR; } if (aIndex >= Length()) { return NS_ERROR_DOM_INDEX_SIZE_ERR; } // We have to return the removed item, so make sure it exists: EnsureItemAt(aIndex); // Notify the DOM item of removal *before* modifying the lists so that the // DOM item can copy its *old* value: ItemAt(aIndex)->RemovingFromList(); NS_ADDREF(*_retval = ItemAt(aIndex)); PRUint32 internalIndex = mItems[aIndex].mInternalDataIndex; PRUint32 segType = SVGPathSegUtils::DecodeType(InternalList().mData[internalIndex]); PRUint32 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(PR_TRUE); #ifdef MOZ_SMIL if (AttrIsAnimating()) { Element()->AnimationNeedsResample(); } #endif return NS_OK; }
already_AddRefed<nsIDOMSVGPoint> DOMSVGPointList::ReplaceItem(nsIDOMSVGPoint *aNewItem, uint32_t aIndex, ErrorResult& aError) { if (IsAnimValList()) { aError.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR); return nullptr; } nsCOMPtr<DOMSVGPoint> domItem = do_QueryInterface(aNewItem); if (!domItem) { aError.Throw(NS_ERROR_DOM_SVG_WRONG_TYPE_ERR); return nullptr; } if (aIndex >= LengthNoFlush()) { aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); return nullptr; } if (domItem->HasOwner() || domItem->IsReadonly()) { domItem = domItem->Clone(); // must do this before changing anything! } nsAttrValue emptyOrOldValue = Element()->WillChangePointList(); if (mItems[aIndex]) { // 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[aIndex]->RemovingFromList(); } InternalList()[aIndex] = domItem->ToSVGPoint(); mItems[aIndex] = domItem; // This MUST come after the ToSVGPoint() call, otherwise that call // would end up reading bad data from InternalList()! domItem->InsertingIntoList(this, aIndex, IsAnimValList()); Element()->DidChangePointList(emptyOrOldValue); if (AttrIsAnimating()) { Element()->AnimationNeedsResample(); } return domItem.forget(); }
NS_IMETHODIMP DOMSVGPointList::RemoveItem(PRUint32 aIndex, nsIDOMSVGPoint **_retval) { *_retval = nsnull; if (IsAnimValList()) { return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR; } if (aIndex >= Length()) { return NS_ERROR_DOM_INDEX_SIZE_ERR; } // 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 make sure it exists: EnsureItemAt(aIndex); // Notify the DOM item of removal *before* modifying the lists so that the // DOM item can copy its *old* value: mItems[aIndex]->RemovingFromList(); NS_ADDREF(*_retval = mItems[aIndex]); InternalList().RemoveItem(aIndex); mItems.RemoveElementAt(aIndex); UpdateListIndicesFromIndex(mItems, aIndex); Element()->DidChangePointList(PR_TRUE); #ifdef MOZ_SMIL if (AttrIsAnimating()) { Element()->AnimationNeedsResample(); } #endif return NS_OK; }
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; } nsAttrValue emptyOrOldValue = Element()->WillChangePointList(); // 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 make sure it exists: EnsureItemAt(aIndex); // Notify the DOM item of removal *before* modifying the lists so that the // DOM item can copy its *old* value: mItems[aIndex]->RemovingFromList(); nsCOMPtr<nsISVGPoint> result = mItems[aIndex]; InternalList().RemoveItem(aIndex); mItems.RemoveElementAt(aIndex); UpdateListIndicesFromIndex(mItems, aIndex); Element()->DidChangePointList(emptyOrOldValue); if (AttrIsAnimating()) { Element()->AnimationNeedsResample(); } return result.forget(); }
bool DOMSVGPointList::AnimListMirrorsBaseList() const { return GetDOMWrapperIfExists(InternalAList().GetAnimValKey()) && !AttrIsAnimating(); }
NS_IMETHODIMP DOMSVGPathSegList::ReplaceItem(nsIDOMSVGPathSeg *aNewItem, PRUint32 aIndex, nsIDOMSVGPathSeg **_retval) { *_retval = nsnull; if (IsAnimValList()) { return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR; } nsCOMPtr<DOMSVGPathSeg> domItem = do_QueryInterface(aNewItem); if (!domItem) { return NS_ERROR_DOM_SVG_WRONG_TYPE_ERR; } if (aIndex >= Length()) { return NS_ERROR_DOM_INDEX_SIZE_ERR; } if (domItem->HasOwner()) { domItem = domItem->Clone(); // must do this before changing anything! } if (ItemAt(aIndex)) { // Notify any existing DOM item of removal *before* modifying the lists so // that the DOM item can copy the *old* value at its index: ItemAt(aIndex)->RemovingFromList(); } PRUint32 internalIndex = mItems[aIndex].mInternalDataIndex; // We use InternalList() to get oldArgCount since we may not have a DOM // wrapper at the index being replaced. PRUint32 oldType = SVGPathSegUtils::DecodeType(InternalList().mData[internalIndex]); PRUint32 oldArgCount = SVGPathSegUtils::ArgCountForType(oldType); PRUint32 newArgCount = SVGPathSegUtils::ArgCountForType(domItem->Type()); float segAsRaw[1 + NS_SVG_PATH_SEG_MAX_ARGS]; domItem->ToSVGPathSegEncodedData(segAsRaw); bool ok = !!InternalList().mData.ReplaceElementsAt( internalIndex, 1 + oldArgCount, segAsRaw, 1 + newArgCount); if (!ok) { return NS_ERROR_OUT_OF_MEMORY; } ItemAt(aIndex) = domItem; // This MUST come after the ToSVGPathSegEncodedData call, otherwise that call // would end up reading bad data from InternalList()! domItem->InsertingIntoList(this, aIndex, IsAnimValList()); PRUint32 delta = newArgCount - oldArgCount; if (delta != 0) { for (PRUint32 i = aIndex + 1; i < Length(); ++i) { mItems[i].mInternalDataIndex += delta; } } Element()->DidChangePathSegList(true); if (AttrIsAnimating()) { Element()->AnimationNeedsResample(); } NS_ADDREF(*_retval = domItem.get()); return NS_OK; }
already_AddRefed<DOMSVGPathSeg> DOMSVGPathSegList::ReplaceItem(DOMSVGPathSeg& aNewItem, 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; } nsRefPtr<DOMSVGPathSeg> domItem = &aNewItem; if (domItem->HasOwner()) { domItem = domItem->Clone(); // must do this before changing anything! } nsAttrValue emptyOrOldValue = Element()->WillChangePathSegList(); if (ItemAt(aIndex)) { // Notify any existing DOM item of removal *before* modifying the lists so // that the DOM item can copy the *old* value at its index: ItemAt(aIndex)->RemovingFromList(); } uint32_t internalIndex = mItems[aIndex].mInternalDataIndex; // We use InternalList() to get oldArgCount since we may not have a DOM // wrapper at the index being replaced. uint32_t oldType = SVGPathSegUtils::DecodeType(InternalList().mData[internalIndex]); // NOTE: ArgCountForType returns a (small) unsigned value, but we're // intentionally putting it in a signed variable, because we're going to // subtract these values and might produce something negative. int32_t oldArgCount = SVGPathSegUtils::ArgCountForType(oldType); int32_t newArgCount = SVGPathSegUtils::ArgCountForType(domItem->Type()); float segAsRaw[1 + NS_SVG_PATH_SEG_MAX_ARGS]; domItem->ToSVGPathSegEncodedData(segAsRaw); bool ok = !!InternalList().mData.ReplaceElementsAt( internalIndex, 1 + oldArgCount, segAsRaw, 1 + newArgCount); if (!ok) { aError.Throw(NS_ERROR_OUT_OF_MEMORY); return nullptr; } ItemAt(aIndex) = domItem; // This MUST come after the ToSVGPathSegEncodedData call, otherwise that call // would end up reading bad data from InternalList()! domItem->InsertingIntoList(this, aIndex, IsAnimValList()); int32_t delta = newArgCount - oldArgCount; if (delta != 0) { for (uint32_t i = aIndex + 1; i < LengthNoFlush(); ++i) { mItems[i].mInternalDataIndex += delta; } } Element()->DidChangePathSegList(emptyOrOldValue); if (AttrIsAnimating()) { Element()->AnimationNeedsResample(); } return domItem.forget(); }