自学教程：C++ AttrIsAnimating函数代码示例

voidDOMSVGPointList::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_IMETHODIMPDOMSVGPathSegList::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;}

voidDOMSVGPathSegList::  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);}

voidDOMSVGPathSegList::  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));}

voidDOMSVGPathSegList::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();  }}

voidDOMSVGPointList::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_IMETHODIMPDOMSVGPathSegList::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;}

voidDOMSVGPointList::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);}

voidDOMSVGPathSegList::  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));}

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();}

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_IMETHODIMPDOMSVGPathSegList::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();}

boolDOMSVGPointList::AnimListMirrorsBaseList() const{  return GetDOMWrapperIfExists(InternalAList().GetAnimValKey()) &&           !AttrIsAnimating();}

NS_IMETHODIMPDOMSVGPathSegList::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();}