gecko/gfx/2d/PathCairo.cpp

364 lines
11 KiB
C++
Raw Normal View History

/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla Corporation code.
*
* The Initial Developer of the Original Code is Mozilla Foundation.
* Portions created by the Initial Developer are Copyright (C) 2011
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "PathCairo.h"
#include <math.h>
#include "DrawTargetCairo.h"
#include "Logging.h"
#include "PathHelpers.h"
#include "HelpersCairo.h"
namespace mozilla {
namespace gfx {
CairoPathContext::CairoPathContext(cairo_t* aCtx, DrawTargetCairo* aDrawTarget,
FillRule aFillRule,
const Matrix& aTransform /* = Matrix() */)
: mTransform(aTransform)
, mContext(aCtx)
, mDrawTarget(aDrawTarget)
, mFillRule(aFillRule)
{
cairo_reference(mContext);
cairo_set_fill_rule(mContext, GfxFillRuleToCairoFillRule(mFillRule));
// If we don't have an identity transformation, we need to have a separate
// context from the draw target, because we can't set a transformation on its
// context.
if (mDrawTarget && !mTransform.IsIdentity()) {
DuplicateContextAndPath(mTransform);
ForgetDrawTarget();
} else if (mDrawTarget) {
mDrawTarget->SetPathObserver(this);
}
}
CairoPathContext::~CairoPathContext()
{
if (mDrawTarget) {
mDrawTarget->SetPathObserver(NULL);
}
cairo_destroy(mContext);
}
void
CairoPathContext::DuplicateContextAndPath(const Matrix& aMatrix /* = Matrix() */)
{
// Duplicate the path.
cairo_path_t* path = cairo_copy_path(mContext);
cairo_fill_rule_t rule = cairo_get_fill_rule(mContext);
// Duplicate the context.
cairo_surface_t* surf = cairo_get_target(mContext);
cairo_destroy(mContext);
mContext = cairo_create(surf);
// Transform the context.
cairo_matrix_t matrix;
GfxMatrixToCairoMatrix(aMatrix, matrix);
cairo_transform(mContext, &matrix);
// Add the path, and throw away our duplicate.
cairo_append_path(mContext, path);
cairo_set_fill_rule(mContext, rule);
cairo_path_destroy(path);
}
void
CairoPathContext::PathWillChange()
{
// Once we've copied out the context's path, there's no use to holding on to
// the draw target. Thus, there's nothing for us to do if we're independent
// of the draw target, since we'll have already copied out the context's
// path.
if (mDrawTarget) {
// The context we point to is going to change from under us. To continue
// using this path, we need to copy it to a new context.
DuplicateContextAndPath();
ForgetDrawTarget();
}
}
void
CairoPathContext::MatrixWillChange(const Matrix& aNewMatrix)
{
// Cairo paths are stored in device space. Since we logically operate in user
// space, we want to make it so our path will be in the same location if and
// when our path is copied out.
// To effect this, we copy out our path (which, in Cairo, implicitly converts
// to user space), then temporarily set the context to have the new
// transform. We then set the path, which ensures that the points are all
// transformed correctly. Finally, we set the matrix back to its original
// value.
cairo_path_t* path = cairo_copy_path(mContext);
cairo_matrix_t origMatrix;
cairo_get_matrix(mContext, &origMatrix);
cairo_matrix_t newMatrix;
GfxMatrixToCairoMatrix(aNewMatrix, newMatrix);
cairo_set_matrix(mContext, &newMatrix);
cairo_new_path(mContext);
cairo_append_path(mContext, path);
cairo_path_destroy(path);
cairo_set_matrix(mContext, &origMatrix);
}
void
CairoPathContext::CopyPathTo(cairo_t* aToContext)
{
if (aToContext != mContext) {
cairo_set_fill_rule(aToContext, GfxFillRuleToCairoFillRule(mFillRule));
cairo_matrix_t origMat;
cairo_get_matrix(aToContext, &origMat);
cairo_matrix_t mat;
GfxMatrixToCairoMatrix(mTransform, mat);
cairo_transform(aToContext, &mat);
// cairo_copy_path gives us a user-space copy of the path, so we don't have
// to worry about transformations here.
cairo_path_t* path = cairo_copy_path(mContext);
cairo_new_path(aToContext);
cairo_append_path(aToContext, path);
cairo_path_destroy(path);
cairo_set_matrix(aToContext, &origMat);
}
}
void
CairoPathContext::ForgetDrawTarget()
{
mDrawTarget = NULL;
}
bool
CairoPathContext::ContainsPath(const Path* aPath)
{
if (aPath->GetBackendType() != BACKEND_CAIRO) {
return false;
}
const PathCairo* path = static_cast<const PathCairo*>(aPath);
RefPtr<CairoPathContext> ctx = const_cast<PathCairo*>(path)->GetPathContext();
return ctx == this;
}
PathBuilderCairo::PathBuilderCairo(CairoPathContext* aPathContext,
const Matrix& aTransform /* = Matrix() */)
: mFillRule(aPathContext->GetFillRule())
{
RefPtr<DrawTargetCairo> drawTarget = aPathContext->GetDrawTarget();
mPathContext = new CairoPathContext(*aPathContext, drawTarget, mFillRule,
aPathContext->GetTransform() * aTransform);
// We need to ensure that we are allowed to modify the path currently set on
// aPathContext. If we don't have a draw target, CairoPathContext's
// constructor has no way to make aPathContext duplicate its path (normally,
// calling drawTarget->SetPathObserver() would do so). In this case, we
// explicitly make aPathContext copy out its context and path, leaving our
// path alone.
if (!drawTarget) {
aPathContext->DuplicateContextAndPath();
}
}
PathBuilderCairo::PathBuilderCairo(cairo_t* aCtx, DrawTargetCairo* aDrawTarget, FillRule aFillRule)
: mPathContext(new CairoPathContext(aCtx, aDrawTarget, aFillRule))
, mFillRule(aFillRule)
{}
void
PathBuilderCairo::MoveTo(const Point &aPoint)
{
cairo_move_to(*mPathContext, aPoint.x, aPoint.y);
}
void
PathBuilderCairo::LineTo(const Point &aPoint)
{
cairo_line_to(*mPathContext, aPoint.x, aPoint.y);
}
void
PathBuilderCairo::BezierTo(const Point &aCP1,
const Point &aCP2,
const Point &aCP3)
{
cairo_curve_to(*mPathContext, aCP1.x, aCP1.y, aCP2.x, aCP2.y, aCP3.x, aCP3.y);
}
void
PathBuilderCairo::QuadraticBezierTo(const Point &aCP1,
const Point &aCP2)
{
// We need to elevate the degree of this quadratic Bézier to cubic, so we're
// going to add an intermediate control point, and recompute control point 1.
// The first and last control points remain the same.
// This formula can be found on http://fontforge.sourceforge.net/bezier.html
Point CP0 = CurrentPoint();
Point CP1 = (CP0 + aCP1 * 2.0) / 3.0;
Point CP2 = (aCP2 + aCP1 * 2.0) / 3.0;
Point CP3 = aCP2;
cairo_curve_to(*mPathContext, CP1.x, CP1.y, CP2.x, CP2.y, CP3.x, CP3.y);
}
void
PathBuilderCairo::Close()
{
cairo_close_path(*mPathContext);
}
void
PathBuilderCairo::Arc(const Point &aOrigin, float aRadius, float aStartAngle,
float aEndAngle, bool aAntiClockwise)
{
ArcToBezier(this, aOrigin, aRadius, aStartAngle, aEndAngle, aAntiClockwise);
}
Point
PathBuilderCairo::CurrentPoint() const
{
double x, y;
cairo_get_current_point(*mPathContext, &x, &y);
return Point(x, y);
}
TemporaryRef<Path>
PathBuilderCairo::Finish()
{
RefPtr<PathCairo> path = new PathCairo(*mPathContext,
mPathContext->GetDrawTarget(),
mFillRule,
mPathContext->GetTransform());
return path;
}
TemporaryRef<CairoPathContext>
PathBuilderCairo::GetPathContext()
{
return mPathContext;
}
PathCairo::PathCairo(cairo_t* aCtx, DrawTargetCairo* aDrawTarget, FillRule aFillRule, const Matrix& aTransform)
: mPathContext(new CairoPathContext(aCtx, aDrawTarget, aFillRule, aTransform))
, mFillRule(aFillRule)
{}
TemporaryRef<PathBuilder>
PathCairo::CopyToBuilder(FillRule aFillRule) const
{
// Note: This PathBuilderCairo constructor causes our mPathContext to copy
// out the path, since the path builder is going to change the path on us.
RefPtr<PathBuilderCairo> builder = new PathBuilderCairo(mPathContext);
return builder;
}
TemporaryRef<PathBuilder>
PathCairo::TransformedCopyToBuilder(const Matrix &aTransform, FillRule aFillRule) const
{
// Note: This PathBuilderCairo constructor causes our mPathContext to copy
// out the path, since the path builder is going to change the path on us.
RefPtr<PathBuilderCairo> builder = new PathBuilderCairo(mPathContext,
aTransform);
return builder;
}
bool
PathCairo::ContainsPoint(const Point &aPoint, const Matrix &aTransform) const
{
Matrix inverse = aTransform;
inverse.Invert();
Point transformed = inverse * aPoint;
return cairo_in_fill(*mPathContext, transformed.x, transformed.y);
}
Rect
PathCairo::GetBounds(const Matrix &aTransform) const
{
double x1, y1, x2, y2;
cairo_path_extents(*mPathContext, &x1, &y1, &x2, &y2);
Rect bounds(x1, y1, x2 - x1, y2 - y1);
return aTransform.TransformBounds(bounds);
}
Rect
PathCairo::GetStrokedBounds(const StrokeOptions &aStrokeOptions,
const Matrix &aTransform) const
{
double x1, y1, x2, y2;
SetCairoStrokeOptions(*mPathContext, aStrokeOptions);
cairo_stroke_extents(*mPathContext, &x1, &y1, &x2, &y2);
Rect bounds(x1, y1, x2 - x1, y2 - y1);
return aTransform.TransformBounds(bounds);
}
TemporaryRef<CairoPathContext>
PathCairo::GetPathContext()
{
return mPathContext;
}
void
PathCairo::CopyPathTo(cairo_t* aContext, DrawTargetCairo* aDrawTarget)
{
if (mPathContext->GetContext() != aContext) {
mPathContext->CopyPathTo(aContext);
// Since aDrawTarget wants us to be the current path on its context, we
// should also listen to it for updates to that path (as an optimization).
// The easiest way to do this is to just recreate mPathContext, since it
// registers with aDrawTarget for updates.
mPathContext = new CairoPathContext(aContext, aDrawTarget,
mPathContext->GetFillRule(),
mPathContext->GetTransform());
}
}
}
}