/usr/include/firefox-esr-52/mozilla/dom/SVGMatrix.h is in firefox-esr-dev 52.8.1esr-1~deb8u1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 | /* -*- 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/. */
/**
* Notes on transforms in Mozilla and the SVG code.
*
* It's important to note that the matrix convention used in the SVG standard
* is the opposite convention to the one used in the Mozilla code or, more
* specifically, the convention used in Thebes code (code using gfxMatrix).
* Whereas the SVG standard uses the column vector convention, Thebes code uses
* the row vector convention. Thus, whereas in the SVG standard you have
* [M1][M2][M3]|p|, in Thebes you have |p|'[M3]'[M2]'[M1]'. In other words, the
* following are equivalent:
*
* / a1 c1 tx1 \ / a2 c2 tx2 \ / a3 c3 tx3 \ / x \
* SVG: | b1 d1 ty1 | | b2 d2 ty2 | | b3 d3 ty3 | | y |
* \ 0 0 1 / \ 0 0 1 / \ 0 0 1 / \ 1 /
*
* / a3 b3 0 \ / a2 b2 0 \ / a1 b1 0 \
* Thebes: [ x y 1 ] | c3 d3 0 | | c2 d2 0 | | c1 d1 0 |
* \ tx3 ty3 1 / \ tx2 ty2 1 / \ tx1 ty1 1 /
*
* Because the Thebes representation of a transform is the transpose of the SVG
* representation, our transform order must be reversed when representing SVG
* transforms using gfxMatrix in the SVG code. Since the SVG implementation
* stores and obtains matrices in SVG order, to do this we must pre-multiply
* gfxMatrix objects that represent SVG transforms instead of post-multiplying
* them as we would for matrices using SVG's column vector convention.
* Pre-multiplying may look wrong if you're only familiar with the SVG
* convention, but in that case hopefully the above explanation clears things
* up.
*/
#ifndef mozilla_dom_SVGMatrix_h
#define mozilla_dom_SVGMatrix_h
#include "mozilla/dom/SVGTransform.h"
#include "gfxMatrix.h"
#include "nsCycleCollectionParticipant.h"
#include "nsWrapperCache.h"
#include "mozilla/Attributes.h"
namespace mozilla {
namespace dom {
/**
* DOM wrapper for an SVG matrix.
*/
class SVGMatrix final : public nsWrapperCache
{
public:
NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(SVGMatrix)
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(SVGMatrix)
/**
* Ctor for SVGMatrix objects that belong to a SVGTransform.
*/
explicit SVGMatrix(SVGTransform& aTransform) : mTransform(&aTransform) {}
/**
* Ctors for SVGMatrix objects created independently of a SVGTransform.
*/
// Default ctor for gfxMatrix will produce identity mx
SVGMatrix() {}
explicit SVGMatrix(const gfxMatrix &aMatrix) : mMatrix(aMatrix) {}
const gfxMatrix& GetMatrix() const {
return mTransform ? mTransform->Matrixgfx() : mMatrix;
}
// WebIDL
SVGTransform* GetParentObject() const;
virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
float A() const { return static_cast<float>(GetMatrix()._11); }
void SetA(float aA, ErrorResult& rv);
float B() const { return static_cast<float>(GetMatrix()._12); }
void SetB(float aB, ErrorResult& rv);
float C() const { return static_cast<float>(GetMatrix()._21); }
void SetC(float aC, ErrorResult& rv);
float D() const { return static_cast<float>(GetMatrix()._22); }
void SetD(float aD, ErrorResult& rv);
float E() const { return static_cast<float>(GetMatrix()._31); }
void SetE(float aE, ErrorResult& rv);
float F() const { return static_cast<float>(GetMatrix()._32); }
void SetF(float aF, ErrorResult& rv);
already_AddRefed<SVGMatrix> Multiply(SVGMatrix& aMatrix);
already_AddRefed<SVGMatrix> Inverse(ErrorResult& aRv);
already_AddRefed<SVGMatrix> Translate(float x, float y);
already_AddRefed<SVGMatrix> Scale(float scaleFactor);
already_AddRefed<SVGMatrix> ScaleNonUniform(float scaleFactorX,
float scaleFactorY);
already_AddRefed<SVGMatrix> Rotate(float angle);
already_AddRefed<SVGMatrix> RotateFromVector(float x,
float y,
ErrorResult& aRv);
already_AddRefed<SVGMatrix> FlipX();
already_AddRefed<SVGMatrix> FlipY();
already_AddRefed<SVGMatrix> SkewX(float angle, ErrorResult& rv);
already_AddRefed<SVGMatrix> SkewY(float angle, ErrorResult& rv);
private:
~SVGMatrix() {}
void SetMatrix(const gfxMatrix& aMatrix) {
if (mTransform) {
mTransform->SetMatrix(aMatrix);
} else {
mMatrix = aMatrix;
}
}
bool IsAnimVal() const {
return mTransform ? mTransform->IsAnimVal() : false;
}
RefPtr<SVGTransform> mTransform;
// Typically we operate on the matrix data accessed via mTransform but for
// matrices that exist independently of an SVGTransform we use mMatrix below.
gfxMatrix mMatrix;
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_SVGMatrix_h
|