mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-30 13:45:27 +00:00
ff59d84e8f
This function is not a virtual function and always returns CAIRO_STATUS_SUCCESS after the patch in bug 1054838 landed. There is no reason to keep it anymore. MozReview-Commit-ID: EadrrFQyjfY --HG-- extra : rebase_source : 3f6a284dc9fa396d5cfd3f64190562373801a0a2
213 lines
6.0 KiB
C++
213 lines
6.0 KiB
C++
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
* 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/. */
|
|
|
|
#include "gfxPattern.h"
|
|
|
|
#include "gfxUtils.h"
|
|
#include "gfxTypes.h"
|
|
#include "gfxASurface.h"
|
|
#include "gfxPlatform.h"
|
|
#include "gfx2DGlue.h"
|
|
#include "gfxGradientCache.h"
|
|
#include "mozilla/gfx/2D.h"
|
|
|
|
#include "cairo.h"
|
|
|
|
#include <vector>
|
|
|
|
using namespace mozilla::gfx;
|
|
|
|
gfxPattern::gfxPattern(const Color& aColor)
|
|
: mExtend(ExtendMode::CLAMP)
|
|
{
|
|
mGfxPattern.InitColorPattern(ToDeviceColor(aColor));
|
|
}
|
|
|
|
// linear
|
|
gfxPattern::gfxPattern(gfxFloat x0, gfxFloat y0, gfxFloat x1, gfxFloat y1)
|
|
: mExtend(ExtendMode::CLAMP)
|
|
{
|
|
mGfxPattern.InitLinearGradientPattern(Point(x0, y0), Point(x1, y1), nullptr);
|
|
}
|
|
|
|
// radial
|
|
gfxPattern::gfxPattern(gfxFloat cx0, gfxFloat cy0, gfxFloat radius0,
|
|
gfxFloat cx1, gfxFloat cy1, gfxFloat radius1)
|
|
: mExtend(ExtendMode::CLAMP)
|
|
{
|
|
mGfxPattern.InitRadialGradientPattern(Point(cx0, cy0), Point(cx1, cy1),
|
|
radius0, radius1, nullptr);
|
|
}
|
|
|
|
// Azure
|
|
gfxPattern::gfxPattern(SourceSurface *aSurface, const Matrix &aPatternToUserSpace)
|
|
: mPatternToUserSpace(aPatternToUserSpace)
|
|
, mExtend(ExtendMode::CLAMP)
|
|
{
|
|
mGfxPattern.InitSurfacePattern(aSurface, mExtend, Matrix(), // matrix is overridden in GetPattern()
|
|
mozilla::gfx::SamplingFilter::GOOD);
|
|
}
|
|
|
|
void
|
|
gfxPattern::AddColorStop(gfxFloat offset, const Color& c)
|
|
{
|
|
if (mGfxPattern.GetPattern()->GetType() != PatternType::LINEAR_GRADIENT &&
|
|
mGfxPattern.GetPattern()->GetType() != PatternType::RADIAL_GRADIENT) {
|
|
return;
|
|
}
|
|
|
|
mStops = nullptr;
|
|
|
|
GradientStop stop;
|
|
stop.offset = offset;
|
|
stop.color = ToDeviceColor(c);
|
|
mStopsList.AppendElement(stop);
|
|
}
|
|
|
|
void
|
|
gfxPattern::SetColorStops(GradientStops* aStops)
|
|
{
|
|
mStops = aStops;
|
|
}
|
|
|
|
void
|
|
gfxPattern::CacheColorStops(const DrawTarget *aDT)
|
|
{
|
|
mStops = gfxGradientCache::GetOrCreateGradientStops(aDT, mStopsList, mExtend);
|
|
}
|
|
|
|
void
|
|
gfxPattern::SetMatrix(const gfxMatrix& aPatternToUserSpace)
|
|
{
|
|
mPatternToUserSpace = ToMatrix(aPatternToUserSpace);
|
|
// Cairo-pattern matrices specify the conversion from DrawTarget to pattern
|
|
// space. Azure pattern matrices specify the conversion from pattern to
|
|
// DrawTarget space.
|
|
mPatternToUserSpace.Invert();
|
|
}
|
|
|
|
gfxMatrix
|
|
gfxPattern::GetMatrix() const
|
|
{
|
|
// invert at the higher precision of gfxMatrix
|
|
// cause we need to convert at some point anyways
|
|
gfxMatrix mat = ThebesMatrix(mPatternToUserSpace);
|
|
mat.Invert();
|
|
return mat;
|
|
}
|
|
|
|
gfxMatrix
|
|
gfxPattern::GetInverseMatrix() const
|
|
{
|
|
return ThebesMatrix(mPatternToUserSpace);
|
|
}
|
|
|
|
Pattern*
|
|
gfxPattern::GetPattern(const DrawTarget *aTarget,
|
|
Matrix *aOriginalUserToDevice)
|
|
{
|
|
Matrix patternToUser = mPatternToUserSpace;
|
|
|
|
if (aOriginalUserToDevice &&
|
|
*aOriginalUserToDevice != aTarget->GetTransform()) {
|
|
// mPatternToUserSpace maps from pattern space to the original user space,
|
|
// but aTarget now has a transform to a different user space. In order for
|
|
// the Pattern* that we return to be usable in aTarget's new user space we
|
|
// need the Pattern's mMatrix to be the transform from pattern space to
|
|
// aTarget's -new- user space. That transform is equivalent to the
|
|
// transform from pattern space to original user space (patternToUser),
|
|
// multiplied by the transform from original user space to device space,
|
|
// multiplied by the transform from device space to current user space.
|
|
|
|
Matrix deviceToCurrentUser = aTarget->GetTransform();
|
|
deviceToCurrentUser.Invert();
|
|
|
|
patternToUser = patternToUser * *aOriginalUserToDevice * deviceToCurrentUser;
|
|
}
|
|
patternToUser.NudgeToIntegers();
|
|
|
|
if (!mStops &&
|
|
!mStopsList.IsEmpty()) {
|
|
mStops = aTarget->CreateGradientStops(mStopsList.Elements(),
|
|
mStopsList.Length(), mExtend);
|
|
}
|
|
|
|
switch (mGfxPattern.GetPattern()->GetType()) {
|
|
case PatternType::SURFACE: {
|
|
SurfacePattern* surfacePattern = static_cast<SurfacePattern*>(mGfxPattern.GetPattern());
|
|
surfacePattern->mMatrix = patternToUser;
|
|
surfacePattern->mExtendMode = mExtend;
|
|
break;
|
|
}
|
|
case PatternType::LINEAR_GRADIENT: {
|
|
LinearGradientPattern* linearGradientPattern = static_cast<LinearGradientPattern*>(mGfxPattern.GetPattern());
|
|
linearGradientPattern->mMatrix = patternToUser;
|
|
linearGradientPattern->mStops = mStops;
|
|
break;
|
|
}
|
|
case PatternType::RADIAL_GRADIENT: {
|
|
RadialGradientPattern* radialGradientPattern = static_cast<RadialGradientPattern*>(mGfxPattern.GetPattern());
|
|
radialGradientPattern->mMatrix = patternToUser;
|
|
radialGradientPattern->mStops = mStops;
|
|
break;
|
|
}
|
|
default:
|
|
/* Reassure the compiler we are handling all the enum values. */
|
|
break;
|
|
}
|
|
|
|
return mGfxPattern.GetPattern();
|
|
}
|
|
|
|
void
|
|
gfxPattern::SetExtend(ExtendMode aExtend)
|
|
{
|
|
mExtend = aExtend;
|
|
mStops = nullptr;
|
|
}
|
|
|
|
bool
|
|
gfxPattern::IsOpaque()
|
|
{
|
|
if (mGfxPattern.GetPattern()->GetType() != PatternType::SURFACE) {
|
|
return false;
|
|
}
|
|
|
|
if (static_cast<SurfacePattern*>(mGfxPattern.GetPattern())->mSurface->GetFormat() == SurfaceFormat::B8G8R8X8) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
gfxPattern::SetSamplingFilter(gfx::SamplingFilter filter)
|
|
{
|
|
if (mGfxPattern.GetPattern()->GetType() != PatternType::SURFACE) {
|
|
return;
|
|
}
|
|
|
|
static_cast<SurfacePattern*>(mGfxPattern.GetPattern())->mSamplingFilter = filter;
|
|
}
|
|
|
|
SamplingFilter
|
|
gfxPattern::SamplingFilter() const
|
|
{
|
|
if (mGfxPattern.GetPattern()->GetType() != PatternType::SURFACE) {
|
|
return gfx::SamplingFilter::GOOD;
|
|
}
|
|
return static_cast<const SurfacePattern*>(mGfxPattern.GetPattern())->mSamplingFilter;
|
|
}
|
|
|
|
bool
|
|
gfxPattern::GetSolidColor(Color& aColorOut)
|
|
{
|
|
if (mGfxPattern.GetPattern()->GetType() == PatternType::COLOR) {
|
|
aColorOut = static_cast<ColorPattern*>(mGfxPattern.GetPattern())->mColor;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|