Source/WebCore/platform/graphics/win/GradientDirect2D.cpp

   1 /*
   2  * Copyright (C) 2016 Apple Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "Gradient.h"
  28
  29 #include "FloatPoint.h"
  30 #include "GraphicsContext.h"
  31 #include <d2d1.h>
  32 #include <wtf/RetainPtr.h>
  33
  34 #define GRADIENT_DRAWING 3
  35
  36 namespace WebCore {
  37
  38 void Gradient::platformDestroy()
  39 {
  40     if (m_gradient)
  41         m_gradient->Release();
  42     m_gradient = nullptr;
  43 }
  44
  45 ID2D1Brush* Gradient::platformGradient()
  46 {
  47     ASSERT(m_gradient);
  48     return m_gradient;
  49 }
  50
  51 ID2D1Brush* Gradient::createPlatformGradientIfNecessary(ID2D1RenderTarget* context)
  52 {
  53     generateGradient(context);
  54     return m_gradient;
  55 }
  56
  57 void Gradient::generateGradient(ID2D1RenderTarget* renderTarget)
  58 {
  59     sortStopsIfNecessary();
  60
  61     Vector<D2D1_GRADIENT_STOP> gradientStops;
  62     // FIXME: Add support for ExtendedColor.
  63     for (auto stop : m_stops) {
  64         float r;
  65         float g;
  66         float b;
  67         float a;
  68         stop.color.getRGBA(r, g, b, a);
  69         gradientStops.append(D2D1::GradientStop(stop.offset, D2D1::ColorF(r, g, b, a)));
  70     }
  71
  72     COMPtr<ID2D1GradientStopCollection> gradientStopCollection;
  73     HRESULT hr = renderTarget->CreateGradientStopCollection(gradientStops.data(), gradientStops.size(), &gradientStopCollection);
  74     RELEASE_ASSERT(SUCCEEDED(hr));
  75
  76     if (m_gradient) {
  77         m_gradient->Release();
  78         m_gradient = nullptr;
  79     }
  80
  81     WTF::switchOn(m_data,
  82         [&] (const LinearData& data) {
  83             ID2D1LinearGradientBrush* linearGradient = nullptr;
  84             hr = renderTarget->CreateLinearGradientBrush(
  85                 D2D1::LinearGradientBrushProperties(data.point0, data.point1),
  86                 D2D1::BrushProperties(), gradientStopCollection.get(),
  87                 &linearGradient);
  88             RELEASE_ASSERT(SUCCEEDED(hr));
  89             m_gradient = linearGradient;
  90         },
  91         [&] (const RadialData& data) {
  92             FloatSize offset = data.point1 - data.point0;
  93             ID2D1RadialGradientBrush* radialGradient = nullptr;
  94             float radiusX = data.endRadius + offset.width();
  95             float radiusY = radiusX / data.aspectRatio;
  96             hr = renderTarget->CreateRadialGradientBrush(
  97                 D2D1::RadialGradientBrushProperties(p0(), D2D1::Point2F(offset.width(), offset.height()), radiusX, radiusY),
  98                 D2D1::BrushProperties(), gradientStopCollection.get(),
  99                 &radialGradient);
 100             RELEASE_ASSERT(SUCCEEDED(hr));
 101             m_gradient = radialGradient;
 102         }
 103     );
 104
 105     hash();
 106 }
 107
 108 void Gradient::fill(GraphicsContext& context, const FloatRect& rect)
 109 {
 110     auto d2dContext = context.platformContext();
 111
 112     WTF::switchOn(m_data,
 113         [&] (const LinearData& data) {
 114             if (!m_cachedHash || !m_gradient)
 115                 generateGradient(d2dContext);
 116
 117             d2dContext->SetTags(GRADIENT_DRAWING, __LINE__);
 118
 119             const D2D1_RECT_F d2dRect = rect;
 120             d2dContext->FillRectangle(&d2dRect, m_gradient);
 121         },
 122         [&] (const RadialData& data) {
 123             bool needScaling = data.aspectRatio != 1;
 124             if (needScaling) {
 125                 context.save();
 126                 // Scale from the center of the gradient. We only ever scale non-deprecated gradients,
 127                 // for which m_p0 == m_p1.
 128                 ASSERT(data.point0 == data.point1);
 129
 130                 D2D1_MATRIX_3X2_F ctm = { };
 131                 d2dContext->GetTransform(&ctm);
 132
 133                 AffineTransform transform(ctm);
 134                 transform.translate(data.point0);
 135                 transform.scaleNonUniform(1.0, 1.0 / data.aspectRatio);
 136                 transform.translate(-data.point0);
 137
 138                 d2dContext->SetTransform(ctm);
 139             }
 140
 141             if (!m_cachedHash || !m_gradient)
 142                 generateGradient(d2dContext);
 143
 144             d2dContext->SetTags(GRADIENT_DRAWING, __LINE__);
 145
 146             const D2D1_RECT_F d2dRect = rect;
 147             d2dContext->FillRectangle(&d2dRect, m_gradient);
 148
 149             if (needScaling)
 150                 context.restore();
 151         }
 152     );
 153 }
 154
 155 }