/* | |

* Copyright 2012 Google Inc. | |

* | |

* Use of this source code is governed by a BSD-style license that can be | |

* found in the LICENSE file. | |

*/ | |

#ifndef SkPathOps_DEFINED | |

#define SkPathOps_DEFINED | |

#include "include/core/SkPath.h" | |

#include "include/core/SkTypes.h" | |

#include "include/private/SkTArray.h" | |

#include "include/private/SkTDArray.h" | |

struct SkRect; | |

// FIXME: move everything below into the SkPath class | |

/** | |

* The logical operations that can be performed when combining two paths. | |

*/ | |

enum SkPathOp { | |

kDifference_SkPathOp, //!< subtract the op path from the first path | |

kIntersect_SkPathOp, //!< intersect the two paths | |

kUnion_SkPathOp, //!< union (inclusive-or) the two paths | |

kXOR_SkPathOp, //!< exclusive-or the two paths | |

kReverseDifference_SkPathOp, //!< subtract the first path from the op path | |

}; | |

/** Set this path to the result of applying the Op to this path and the | |

specified path: this = (this op operand). | |

The resulting path will be constructed from non-overlapping contours. | |

The curve order is reduced where possible so that cubics may be turned | |

into quadratics, and quadratics maybe turned into lines. | |

Returns true if operation was able to produce a result; | |

otherwise, result is unmodified. | |

@param one The first operand (for difference, the minuend) | |

@param two The second operand (for difference, the subtrahend) | |

@param op The operator to apply. | |

@param result The product of the operands. The result may be one of the | |

inputs. | |

@return True if the operation succeeded. | |

*/ | |

bool SK_API Op(const SkPath& one, const SkPath& two, SkPathOp op, SkPath* result); | |

/** Set this path to a set of non-overlapping contours that describe the | |

same area as the original path. | |

The curve order is reduced where possible so that cubics may | |

be turned into quadratics, and quadratics maybe turned into lines. | |

Returns true if operation was able to produce a result; | |

otherwise, result is unmodified. | |

@param path The path to simplify. | |

@param result The simplified path. The result may be the input. | |

@return True if simplification succeeded. | |

*/ | |

bool SK_API Simplify(const SkPath& path, SkPath* result); | |

/** Set the resulting rectangle to the tight bounds of the path. | |

@param path The path measured. | |

@param result The tight bounds of the path. | |

@return True if the bounds could be computed. | |

*/ | |

bool SK_API TightBounds(const SkPath& path, SkRect* result); | |

/** Set the result with fill type winding to area equivalent to path. | |

Returns true if successful. Does not detect if path contains contours which | |

contain self-crossings or cross other contours; in these cases, may return | |

true even though result does not fill same area as path. | |

Returns true if operation was able to produce a result; | |

otherwise, result is unmodified. The result may be the input. | |

@param path The path typically with fill type set to even odd. | |

@param result The equivalent path with fill type set to winding. | |

@return True if winding path was set. | |

*/ | |

bool SK_API AsWinding(const SkPath& path, SkPath* result); | |

/** Perform a series of path operations, optimized for unioning many paths together. | |

*/ | |

class SK_API SkOpBuilder { | |

public: | |

/** Add one or more paths and their operand. The builder is empty before the first | |

path is added, so the result of a single add is (emptyPath OP path). | |

@param path The second operand. | |

@param _operator The operator to apply to the existing and supplied paths. | |

*/ | |

void add(const SkPath& path, SkPathOp _operator); | |

/** Computes the sum of all paths and operands, and resets the builder to its | |

initial state. | |

@param result The product of the operands. | |

@return True if the operation succeeded. | |

*/ | |

bool resolve(SkPath* result); | |

private: | |

SkTArray<SkPath> fPathRefs; | |

SkTDArray<SkPathOp> fOps; | |

static bool FixWinding(SkPath* path); | |

static void ReversePath(SkPath* path); | |

void reset(); | |

}; | |

#endif |