DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (b6d82b1a6b02)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef MOZILLA_SVGMOTIONSMILANIMATIONFUNCTION_H_
#define MOZILLA_SVGMOTIONSMILANIMATIONFUNCTION_H_

#include "mozilla/gfx/2D.h"
#include "mozilla/RefPtr.h"
#include "mozilla/SMILAnimationFunction.h"
#include "SVGMotionSMILType.h"
#include "nsTArray.h"

class nsAttrValue;
class nsAtom;
class nsIContent;

namespace mozilla {

class SMILAttr;
class SMILValue;

namespace dom {
class SVGMPathElement;
}  // namespace dom

//----------------------------------------------------------------------
// SVGMotionSMILAnimationFunction
//
// Subclass of SMILAnimationFunction to support a few extra features offered
// by the <animateMotion> element.
//
class SVGMotionSMILAnimationFunction final : public SMILAnimationFunction {
  typedef mozilla::gfx::Path Path;

 public:
  SVGMotionSMILAnimationFunction();
  virtual bool SetAttr(nsAtom* aAttribute, const nsAString& aValue,
                       nsAttrValue& aResult,
                       nsresult* aParseResult = nullptr) override;
  virtual bool UnsetAttr(nsAtom* aAttribute) override;

  // Method to allow our owner-element to signal us when our <mpath>
  // has changed or been added/removed.  When that happens, we need to
  // mark ourselves as changed so we'll get recomposed, and mark our path data
  // as stale so it'll get regenerated (regardless of mPathSourceType, since
  // <mpath> trumps all the other sources of path data)
  void MpathChanged() { mIsPathStale = mHasChanged = true; }

 protected:
  enum PathSourceType {
    // NOTE: Ordering matters here. Higher-priority path-descriptors should
    // have higher enumerated values
    ePathSourceType_None,    // uninitialized or not applicable
    ePathSourceType_ByAttr,  // by or from-by animation
    ePathSourceType_ToAttr,  // to or from-to animation
    ePathSourceType_ValuesAttr,
    ePathSourceType_PathAttr,
    ePathSourceType_Mpath
  };

  virtual SMILCalcMode GetCalcMode() const override;
  virtual nsresult GetValues(const SMILAttr& aSMILAttr,
                             SMILValueArray& aResult) override;
  virtual void CheckValueListDependentAttrs(uint32_t aNumValues) override;

  virtual bool IsToAnimation() const override;

  void CheckKeyPoints();
  nsresult SetKeyPoints(const nsAString& aKeyPoints, nsAttrValue& aResult);
  void UnsetKeyPoints();
  nsresult SetRotate(const nsAString& aRotate, nsAttrValue& aResult);
  void UnsetRotate();

  // Helpers for GetValues
  void MarkStaleIfAttributeAffectsPath(nsAtom* aAttribute);
  void RebuildPathAndVertices(const nsIContent* aTargetElement);
  void RebuildPathAndVerticesFromMpathElem(dom::SVGMPathElement* aMpathElem);
  void RebuildPathAndVerticesFromPathAttr();
  void RebuildPathAndVerticesFromBasicAttrs(const nsIContent* aContextElem);
  bool GenerateValuesForPathAndPoints(Path* aPath, bool aIsKeyPoints,
                                      FallibleTArray<double>& aPointDistances,
                                      SMILValueArray& aResult);

  // Members
  // -------
  FallibleTArray<double> mKeyPoints;  // parsed from "keyPoints" attribute.

  RotateType mRotateType;  // auto, auto-reverse, or explicit.
  float mRotateAngle;      // the angle value, if explicit.

  PathSourceType mPathSourceType;        // source of our Path.
  RefPtr<Path> mPath;                    // representation of motion path.
  FallibleTArray<double> mPathVertices;  // distances of vertices along path.

  bool mIsPathStale;
};

}  // namespace mozilla

#endif  // MOZILLA_SVGMOTIONSMILANIMATIONFUNCTION_H_