зеркало из https://github.com/mozilla/gecko-dev.git
260 строки
9.7 KiB
C++
260 строки
9.7 KiB
C++
/* -*- 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_SVGPATHSEGUTILS_H__
|
|
#define MOZILLA_SVGPATHSEGUTILS_H__
|
|
|
|
#include "mozilla/ArrayUtils.h"
|
|
#include "mozilla/dom/SVGPathSegBinding.h"
|
|
#include "mozilla/gfx/Point.h"
|
|
#include "nsDebug.h"
|
|
|
|
namespace mozilla {
|
|
|
|
#define NS_SVG_PATH_SEG_MAX_ARGS 7
|
|
#define NS_SVG_PATH_SEG_FIRST_VALID_TYPE dom::SVGPathSeg_Binding::PATHSEG_CLOSEPATH
|
|
#define NS_SVG_PATH_SEG_LAST_VALID_TYPE dom::SVGPathSeg_Binding::PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL
|
|
#define NS_SVG_PATH_SEG_TYPE_COUNT (NS_SVG_PATH_SEG_LAST_VALID_TYPE + 1)
|
|
|
|
/**
|
|
* Code that works with path segments can use an instance of this class to
|
|
* store/provide information about the start of the current subpath and the
|
|
* last path segment (if any).
|
|
*/
|
|
struct SVGPathTraversalState
|
|
{
|
|
typedef gfx::Point Point;
|
|
|
|
enum TraversalMode {
|
|
eUpdateAll,
|
|
eUpdateOnlyStartAndCurrentPos
|
|
};
|
|
|
|
SVGPathTraversalState()
|
|
: start(0.0, 0.0)
|
|
, pos(0.0, 0.0)
|
|
, cp1(0.0, 0.0)
|
|
, cp2(0.0, 0.0)
|
|
, length(0.0)
|
|
, mode(eUpdateAll)
|
|
{}
|
|
|
|
bool ShouldUpdateLengthAndControlPoints() { return mode == eUpdateAll; }
|
|
|
|
Point start; // start point of current sub path (reset each moveto)
|
|
|
|
Point pos; // current position (end point of previous segment)
|
|
|
|
Point cp1; // quadratic control point - if the previous segment was a
|
|
// quadratic bezier curve then this is set to the absolute
|
|
// position of its control point, otherwise its set to pos
|
|
|
|
Point cp2; // cubic control point - if the previous segment was a cubic
|
|
// bezier curve then this is set to the absolute position of
|
|
// its second control point, otherwise it's set to pos
|
|
|
|
float length; // accumulated path length
|
|
|
|
TraversalMode mode; // indicates what to track while traversing a path
|
|
};
|
|
|
|
|
|
/**
|
|
* This class is just a collection of static methods - it doesn't have any data
|
|
* members, and it's not possible to create instances of this class. This class
|
|
* exists purely as a convenient place to gather together a bunch of methods
|
|
* related to manipulating and answering questions about path segments.
|
|
* Internally we represent path segments purely as an array of floats. See the
|
|
* comment documenting SVGPathData for more info on that.
|
|
*
|
|
* The DOM wrapper classes for encoded path segments (data contained in
|
|
* instances of SVGPathData) is DOMSVGPathSeg and its sub-classes. Note that
|
|
* there are multiple different DOM classes for path segs - one for each of the
|
|
* 19 SVG 1.1 segment types.
|
|
*/
|
|
class SVGPathSegUtils
|
|
{
|
|
private:
|
|
SVGPathSegUtils(){} // private to prevent instances
|
|
|
|
public:
|
|
|
|
static void GetValueAsString(const float *aSeg, nsAString& aValue);
|
|
|
|
/**
|
|
* Encode a segment type enum to a float.
|
|
*
|
|
* At some point in the future we will likely want to encode other
|
|
* information into the float, such as whether the command was explicit or
|
|
* not. For now all this method does is save on int to float runtime
|
|
* conversion by requiring uint32_t and float to be of the same size so we
|
|
* can simply do a bitwise uint32_t<->float copy.
|
|
*/
|
|
static float EncodeType(uint32_t aType) {
|
|
static_assert(sizeof(uint32_t) == sizeof(float), "sizeof uint32_t and float must be the same");
|
|
MOZ_ASSERT(IsValidType(aType), "Seg type not recognized");
|
|
return *(reinterpret_cast<float*>(&aType));
|
|
}
|
|
|
|
static uint32_t DecodeType(float aType) {
|
|
static_assert(sizeof(uint32_t) == sizeof(float), "sizeof uint32_t and float must be the same");
|
|
uint32_t type = *(reinterpret_cast<uint32_t*>(&aType));
|
|
MOZ_ASSERT(IsValidType(type), "Seg type not recognized");
|
|
return type;
|
|
}
|
|
|
|
static char16_t GetPathSegTypeAsLetter(uint32_t aType) {
|
|
MOZ_ASSERT(IsValidType(aType), "Seg type not recognized");
|
|
|
|
static const char16_t table[] = {
|
|
char16_t('x'), // 0 == PATHSEG_UNKNOWN
|
|
char16_t('z'), // 1 == PATHSEG_CLOSEPATH
|
|
char16_t('M'), // 2 == PATHSEG_MOVETO_ABS
|
|
char16_t('m'), // 3 == PATHSEG_MOVETO_REL
|
|
char16_t('L'), // 4 == PATHSEG_LINETO_ABS
|
|
char16_t('l'), // 5 == PATHSEG_LINETO_REL
|
|
char16_t('C'), // 6 == PATHSEG_CURVETO_CUBIC_ABS
|
|
char16_t('c'), // 7 == PATHSEG_CURVETO_CUBIC_REL
|
|
char16_t('Q'), // 8 == PATHSEG_CURVETO_QUADRATIC_ABS
|
|
char16_t('q'), // 9 == PATHSEG_CURVETO_QUADRATIC_REL
|
|
char16_t('A'), // 10 == PATHSEG_ARC_ABS
|
|
char16_t('a'), // 11 == PATHSEG_ARC_REL
|
|
char16_t('H'), // 12 == PATHSEG_LINETO_HORIZONTAL_ABS
|
|
char16_t('h'), // 13 == PATHSEG_LINETO_HORIZONTAL_REL
|
|
char16_t('V'), // 14 == PATHSEG_LINETO_VERTICAL_ABS
|
|
char16_t('v'), // 15 == PATHSEG_LINETO_VERTICAL_REL
|
|
char16_t('S'), // 16 == PATHSEG_CURVETO_CUBIC_SMOOTH_ABS
|
|
char16_t('s'), // 17 == PATHSEG_CURVETO_CUBIC_SMOOTH_REL
|
|
char16_t('T'), // 18 == PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS
|
|
char16_t('t') // 19 == PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL
|
|
};
|
|
static_assert(MOZ_ARRAY_LENGTH(table) == NS_SVG_PATH_SEG_TYPE_COUNT, "Unexpected table size");
|
|
|
|
return table[aType];
|
|
}
|
|
|
|
static uint32_t ArgCountForType(uint32_t aType) {
|
|
MOZ_ASSERT(IsValidType(aType), "Seg type not recognized");
|
|
|
|
static const uint8_t table[] = {
|
|
0, // 0 == PATHSEG_UNKNOWN
|
|
0, // 1 == PATHSEG_CLOSEPATH
|
|
2, // 2 == PATHSEG_MOVETO_ABS
|
|
2, // 3 == PATHSEG_MOVETO_REL
|
|
2, // 4 == PATHSEG_LINETO_ABS
|
|
2, // 5 == PATHSEG_LINETO_REL
|
|
6, // 6 == PATHSEG_CURVETO_CUBIC_ABS
|
|
6, // 7 == PATHSEG_CURVETO_CUBIC_REL
|
|
4, // 8 == PATHSEG_CURVETO_QUADRATIC_ABS
|
|
4, // 9 == PATHSEG_CURVETO_QUADRATIC_REL
|
|
7, // 10 == PATHSEG_ARC_ABS
|
|
7, // 11 == PATHSEG_ARC_REL
|
|
1, // 12 == PATHSEG_LINETO_HORIZONTAL_ABS
|
|
1, // 13 == PATHSEG_LINETO_HORIZONTAL_REL
|
|
1, // 14 == PATHSEG_LINETO_VERTICAL_ABS
|
|
1, // 15 == PATHSEG_LINETO_VERTICAL_REL
|
|
4, // 16 == PATHSEG_CURVETO_CUBIC_SMOOTH_ABS
|
|
4, // 17 == PATHSEG_CURVETO_CUBIC_SMOOTH_REL
|
|
2, // 18 == PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS
|
|
2 // 19 == PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL
|
|
};
|
|
static_assert(MOZ_ARRAY_LENGTH(table) == NS_SVG_PATH_SEG_TYPE_COUNT, "Unexpected table size");
|
|
|
|
return table[aType];
|
|
}
|
|
|
|
/**
|
|
* Convenience so that callers can pass a float containing an encoded type
|
|
* and have it decoded implicitly.
|
|
*/
|
|
static uint32_t ArgCountForType(float aType) {
|
|
return ArgCountForType(DecodeType(aType));
|
|
}
|
|
|
|
static bool IsValidType(uint32_t aType) {
|
|
return aType >= NS_SVG_PATH_SEG_FIRST_VALID_TYPE &&
|
|
aType <= NS_SVG_PATH_SEG_LAST_VALID_TYPE;
|
|
}
|
|
|
|
static bool IsCubicType(uint32_t aType) {
|
|
return aType == dom::SVGPathSeg_Binding::PATHSEG_CURVETO_CUBIC_REL ||
|
|
aType == dom::SVGPathSeg_Binding::PATHSEG_CURVETO_CUBIC_ABS ||
|
|
aType == dom::SVGPathSeg_Binding::PATHSEG_CURVETO_CUBIC_SMOOTH_REL ||
|
|
aType == dom::SVGPathSeg_Binding::PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;
|
|
}
|
|
|
|
static bool IsQuadraticType(uint32_t aType) {
|
|
return aType == dom::SVGPathSeg_Binding::PATHSEG_CURVETO_QUADRATIC_REL ||
|
|
aType == dom::SVGPathSeg_Binding::PATHSEG_CURVETO_QUADRATIC_ABS ||
|
|
aType == dom::SVGPathSeg_Binding::PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL ||
|
|
aType == dom::SVGPathSeg_Binding::PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;
|
|
}
|
|
|
|
static bool IsArcType(uint32_t aType) {
|
|
return aType == dom::SVGPathSeg_Binding::PATHSEG_ARC_ABS ||
|
|
aType == dom::SVGPathSeg_Binding::PATHSEG_ARC_REL;
|
|
}
|
|
|
|
static bool IsRelativeOrAbsoluteType(uint32_t aType) {
|
|
MOZ_ASSERT(IsValidType(aType), "Seg type not recognized");
|
|
|
|
// When adding a new path segment type, ensure that the returned condition
|
|
// below is still correct.
|
|
static_assert(NS_SVG_PATH_SEG_LAST_VALID_TYPE ==
|
|
dom::SVGPathSeg_Binding::PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL,
|
|
"Unexpected type");
|
|
|
|
return aType >= dom::SVGPathSeg_Binding::PATHSEG_MOVETO_ABS;
|
|
}
|
|
|
|
static bool IsRelativeType(uint32_t aType) {
|
|
MOZ_ASSERT
|
|
(IsRelativeOrAbsoluteType(aType),
|
|
"IsRelativeType called with segment type that does not come in relative and absolute forms");
|
|
|
|
// When adding a new path segment type, ensure that the returned condition
|
|
// below is still correct.
|
|
static_assert(NS_SVG_PATH_SEG_LAST_VALID_TYPE ==
|
|
dom::SVGPathSeg_Binding::PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL,
|
|
"Unexpected type");
|
|
|
|
return aType & 1;
|
|
}
|
|
|
|
static uint32_t RelativeVersionOfType(uint32_t aType) {
|
|
MOZ_ASSERT
|
|
(IsRelativeOrAbsoluteType(aType),
|
|
"RelativeVersionOfType called with segment type that does not come in relative and absolute forms");
|
|
|
|
// When adding a new path segment type, ensure that the returned condition
|
|
// below is still correct.
|
|
static_assert(NS_SVG_PATH_SEG_LAST_VALID_TYPE ==
|
|
dom::SVGPathSeg_Binding::PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL,
|
|
"Unexpected type");
|
|
|
|
return aType | 1;
|
|
}
|
|
|
|
static uint32_t SameTypeModuloRelativeness(uint32_t aType1, uint32_t aType2) {
|
|
if (!IsRelativeOrAbsoluteType(aType1)) {
|
|
return aType1 == aType2;
|
|
}
|
|
|
|
return RelativeVersionOfType(aType1) == RelativeVersionOfType(aType2);
|
|
}
|
|
|
|
/**
|
|
* Traverse the given path segment and update the SVGPathTraversalState
|
|
* object.
|
|
*/
|
|
static void TraversePathSegment(const float* aData,
|
|
SVGPathTraversalState& aState);
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif // MOZILLA_SVGPATHSEGUTILS_H__
|