Changeset 235772 in webkit


Ignore:
Timestamp:
Sep 6, 2018 6:36:36 PM (6 years ago)
Author:
Megan Gardner
Message:

Add Support for Conic Gradients
https://bugs.webkit.org/show_bug.cgi?id=189329
<rdar://problem/21444701>

Reviewed by Simon Fraser.

Source/WebCore:

Add support for rendering CSS conic gradients.
The parsing work was already done, this just hooks up the data we have
with the CG functionality for conic gradients. Add the needed plumbing
to allow for this additional type and fill in the creation of
a conic gradient.

Tests: fast/gradients/conic-repeating.html

fast/gradients/conic.html

  • css/CSSGradientValue.cpp:

(WebCore::createGradient):
(WebCore::LinearGradientAdapter::gradientLength const):
(WebCore::RadialGradientAdapter::gradientLength const):
(WebCore::ConicGradientAdapter::ConicGradientAdapter):
(WebCore::ConicGradientAdapter::gradientLength const):
(WebCore::ConicGradientAdapter::maxExtent const):
(WebCore::ConicGradientAdapter::normalizeStopsAndEndpointsOutsideRange):

Compute what the color stops should be if they extend past 0-1

(WebCore::CSSGradientValue::computeStops):
(WebCore::CSSConicGradientValue::createGradient):
(WebCore::LinearGradientAdapter::startPoint const): Deleted.
(WebCore::LinearGradientAdapter::endPoint const): Deleted.
(WebCore::RadialGradientAdapter::startPoint const): Deleted.
(WebCore::RadialGradientAdapter::endPoint const): Deleted.

Start and End points weren't very universal. All we really need from these
gradientAdapters is their length, so just ask for that instead.

  • inspector/InspectorCanvas.cpp:

(WebCore::InspectorCanvas::buildArrayForCanvasGradient):

  • platform/graphics/Gradient.cpp:

(WebCore::Gradient::create):
(WebCore::Gradient::Gradient):
(WebCore::Gradient::type const):
(WebCore::Gradient::adjustParametersForTiledDrawing):
(WebCore::Gradient::isZeroSize const):
(WebCore::Gradient::hash const):

  • platform/graphics/Gradient.h:
  • platform/graphics/cg/GradientCG.cpp:

(WebCore::Gradient::paint):

Source/WebCore/PAL:

Define the CG functionality for conic gradients.

  • pal/spi/cg/CoreGraphicsSPI.h:

Source/WebKit:

Connect up web preferences to allow conic gradients to be turned on in the
experimental features menu.

  • Shared/WebPreferences.yaml:

LayoutTests:

Simple tests to see if conic gradients are rendered properly.

  • fast/gradients/conic-expected.html: Added.
  • fast/gradients/conic-repeating-expected.html: Added.
  • fast/gradients/conic-repeating.html: Added.
  • fast/gradients/conic.html: Added.
Location:
trunk
Files:
10 added
17 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r235763 r235772  
     12018-09-06  Megan Gardner  <megan_gardner@apple.com>
     2
     3        Add Support for Conic Gradients
     4        https://bugs.webkit.org/show_bug.cgi?id=189329
     5        <rdar://problem/21444701>
     6
     7        Reviewed by Simon Fraser.
     8
     9        Simple tests to see if conic gradients are rendered properly.
     10
     11        * fast/gradients/conic-expected.html: Added.
     12        * fast/gradients/conic-repeating-expected.html: Added.
     13        * fast/gradients/conic-repeating.html: Added.
     14        * fast/gradients/conic.html: Added.
     15
    1162018-09-06  Zalan Bujtas  <zalan@apple.com>
    217
  • trunk/LayoutTests/TestExpectations

    r235669 r235772  
    22402240
    22412241webkit.org/b/185308 legacy-animation-engine/animations/combo-transform-translate+scale.html [ Pass Failure ]
     2242
     2243fast/gradients/conic-repeating.html [ Skip ]
     2244fast/gradients/conic.html [ Skip ]
     2245fast/gradients/conic-off-center.html [ Skip ]
     2246fast/gradients/conic-center-outside-box.html [ Skip ]
     2247fast/gradients/conic-extended-stops.html [ Skip ]
  • trunk/LayoutTests/platform/ios-12/TestExpectations

    r234629 r235772  
    2626# <rdar://problem/41546970> REGRESSION: LayoutTest media/media-fullscreen-loop-inline.html is a flaky timeout
    2727media/media-fullscreen-loop-inline.html [ Pass Timeout ]
     28
     29# < iOS12 doesn't support the CG needed for Conic Gradients
     30fast/gradients/conic-repeating.html [ Pass ]
     31fast/gradients/conic.html [ Pass ]
     32fast/gradients/conic-off-center.html [ Pass ]
     33fast/gradients/conic-center-outside-box.html [ Pass ]
     34fast/gradients/conic-extended-stops.html [ Pass ]
  • trunk/LayoutTests/platform/mac/TestExpectations

    r235660 r235772  
    17571757[ Mojave+ ] imported/blink/fast/text/international/text-shaping-arabic.html [ ImageOnlyFailure ]
    17581758[ Mojave+ ] imported/blink/fast/text/international/vertical-positioning-with-combining-marks.html [ ImageOnlyFailure ]
     1759
     1760# < Mojave doesn't support the CG needed for Conic Gradients
     1761[ Mojave+ ] fast/gradients/conic-repeating.html [ Pass ]
     1762[ Mojave+ ] fast/gradients/conic.html [ Pass ]
     1763[ Mojave+ ] fast/gradients/conic-off-center.html [ Pass ]
     1764[ Mojave+ ] fast/gradients/conic-center-outside-box.html [ Pass ]
     1765[ Mojave+ ] fast/gradients/conic-extended-stops.html [ Pass ]
     1766
  • trunk/Source/WebCore/ChangeLog

    r235769 r235772  
     12018-09-06  Megan Gardner  <megan_gardner@apple.com>
     2
     3        Add Support for Conic Gradients
     4        https://bugs.webkit.org/show_bug.cgi?id=189329
     5        <rdar://problem/21444701>
     6
     7        Reviewed by Simon Fraser.
     8
     9        Add support for rendering CSS conic gradients.
     10        The parsing work was already done, this just hooks up the data we have
     11        with the CG functionality for conic gradients. Add the needed plumbing
     12        to allow for this additional type and fill in the creation of
     13        a conic gradient.
     14
     15        Tests: fast/gradients/conic-repeating.html
     16               fast/gradients/conic.html
     17
     18        * css/CSSGradientValue.cpp:
     19        (WebCore::createGradient):
     20        (WebCore::LinearGradientAdapter::gradientLength const):
     21        (WebCore::RadialGradientAdapter::gradientLength const):
     22        (WebCore::ConicGradientAdapter::ConicGradientAdapter):
     23        (WebCore::ConicGradientAdapter::gradientLength const):
     24        (WebCore::ConicGradientAdapter::maxExtent const):
     25        (WebCore::ConicGradientAdapter::normalizeStopsAndEndpointsOutsideRange):
     26
     27        Compute what the color stops should be if they extend past 0-1
     28
     29        (WebCore::CSSGradientValue::computeStops):
     30        (WebCore::CSSConicGradientValue::createGradient):
     31        (WebCore::LinearGradientAdapter::startPoint const): Deleted.
     32        (WebCore::LinearGradientAdapter::endPoint const): Deleted.
     33        (WebCore::RadialGradientAdapter::startPoint const): Deleted.
     34        (WebCore::RadialGradientAdapter::endPoint const): Deleted.
     35
     36        Start and End points weren't very universal. All we really need from these
     37        gradientAdapters is their length, so just ask for that instead.
     38
     39        * inspector/InspectorCanvas.cpp:
     40        (WebCore::InspectorCanvas::buildArrayForCanvasGradient):
     41        * platform/graphics/Gradient.cpp:
     42        (WebCore::Gradient::create):
     43        (WebCore::Gradient::Gradient):
     44        (WebCore::Gradient::type const):
     45        (WebCore::Gradient::adjustParametersForTiledDrawing):
     46        (WebCore::Gradient::isZeroSize const):
     47        (WebCore::Gradient::hash const):
     48        * platform/graphics/Gradient.h:
     49        * platform/graphics/cg/GradientCG.cpp:
     50        (WebCore::Gradient::paint):
     51
    1522018-09-06  Wenson Hsieh  <wenson_hsieh@apple.com>
    253
  • trunk/Source/WebCore/PAL/ChangeLog

    r235620 r235772  
     12018-09-06  Megan Gardner  <megan_gardner@apple.com>
     2
     3        Add Support for Conic Gradients
     4        https://bugs.webkit.org/show_bug.cgi?id=189329
     5        <rdar://problem/21444701>
     6
     7        Reviewed by Simon Fraser.
     8
     9        Define the CG functionality for conic gradients.
     10
     11        * pal/spi/cg/CoreGraphicsSPI.h:
     12
    1132018-09-04  Ryan Haddad  <ryanhaddad@apple.com>
    214
  • trunk/Source/WebCore/PAL/pal/spi/cg/CoreGraphicsSPI.h

    r235154 r235772  
    280280CGStyleRef CGStyleCreateFocusRingWithColor(const CGFocusRingStyle*, CGColorRef);
    281281void CGContextSetStyle(CGContextRef, CGStyleRef);
     282
     283void CGContextDrawConicGradient(CGContextRef, CGGradientRef, CGPoint center, CGFloat angle);
    282284#endif
    283285
  • trunk/Source/WebCore/css/CSSGradientValue.cpp

    r232559 r235772  
    4646    if (is<CSSLinearGradientValue>(value))
    4747        return downcast<CSSLinearGradientValue>(value).createGradient(renderer, size);
    48     return downcast<CSSRadialGradientValue>(value).createGradient(renderer, size);
     48    if (is<CSSRadialGradientValue>(value))
     49        return downcast<CSSRadialGradientValue>(value).createGradient(renderer, size);
     50    return downcast<CSSConicGradientValue>(value).createGradient(renderer, size);
    4951}
    5052
     
    126128    {
    127129    }
    128 
    129     FloatPoint startPoint() const { return m_data.point0; }
    130     FloatPoint endPoint() const { return m_data.point1; }
     130   
     131    float gradientLength() const
     132    {
     133        auto gradientSize = m_data.point0 - m_data.point1;
     134        return gradientSize.diagonalLength();
     135    }
    131136    float maxExtent(float, float) const { return 1; }
    132137
     
    163168    }
    164169
    165     FloatPoint startPoint() const { return m_data.point0; }
    166     FloatPoint endPoint() const { return m_data.point0 + FloatSize { m_data.endRadius, 0 }; }
     170    float gradientLength() const { return m_data.endRadius; }
    167171
    168172    // Radial gradients may need to extend further than the endpoints, because they have
     
    225229};
    226230
     231class ConicGradientAdapter {
     232public:
     233    explicit ConicGradientAdapter() { }
     234    float gradientLength() const { return 1; }
     235    float maxExtent(float, float) const { return 1; }
     236
     237    void normalizeStopsAndEndpointsOutsideRange(Vector<GradientStop>& stops)
     238    {
     239        auto numStops = stops.size();
     240       
     241        size_t firstZeroOrGreaterIndex = numStops;
     242        for (size_t i = 0; i < numStops; ++i) {
     243            if (stops[i].offset >= 0) {
     244                firstZeroOrGreaterIndex = i;
     245                break;
     246            }
     247        }
     248
     249        if (firstZeroOrGreaterIndex > 0) {
     250            if (firstZeroOrGreaterIndex < numStops && stops[firstZeroOrGreaterIndex].offset > 0) {
     251                float prevOffset = stops[firstZeroOrGreaterIndex - 1].offset;
     252                float nextOffset = stops[firstZeroOrGreaterIndex].offset;
     253               
     254                float interStopProportion = -prevOffset / (nextOffset - prevOffset);
     255                // FIXME: when we interpolate gradients using premultiplied colors, this should do premultiplication.
     256                Color blendedColor = blend(stops[firstZeroOrGreaterIndex - 1].color, stops[firstZeroOrGreaterIndex].color, interStopProportion);
     257               
     258                // Clamp the positions to 0 and set the color.
     259                for (size_t i = 0; i < firstZeroOrGreaterIndex; ++i) {
     260                    stops[i].offset = 0;
     261                    stops[i].color = blendedColor;
     262                }
     263            } else {
     264                // All stops are below 0; just clamp them.
     265                for (size_t i = 0; i < firstZeroOrGreaterIndex; ++i)
     266                    stops[i].offset = 0;
     267            }
     268        }
     269
     270        size_t lastOneOrLessIndex = numStops;
     271        for (int i = numStops - 1; i >= 0; --i) {
     272            if (stops[i].offset <= 1) {
     273                lastOneOrLessIndex = i;
     274                break;
     275            }
     276        }
     277       
     278        if (lastOneOrLessIndex < numStops - 1) {
     279            if (lastOneOrLessIndex < numStops && stops[lastOneOrLessIndex].offset < 1) {
     280                float prevOffset = stops[lastOneOrLessIndex].offset;
     281                float nextOffset = stops[lastOneOrLessIndex + 1].offset;
     282               
     283                float interStopProportion = 1 / (nextOffset - prevOffset);
     284                // FIXME: when we interpolate gradients using premultiplied colors, this should do premultiplication.
     285                Color blendedColor = blend(stops[lastOneOrLessIndex].color, stops[lastOneOrLessIndex + 1].color, interStopProportion);
     286               
     287                // Clamp the positions to 1 and set the color.
     288                for (size_t i = lastOneOrLessIndex + 1; i < numStops; ++i) {
     289                    stops[i].offset = 1;
     290                    stops[i].color = blendedColor;
     291                }
     292            } else {
     293                // All stops are above 1; just clamp them.
     294                for (size_t i = lastOneOrLessIndex; i < numStops; ++i)
     295                    stops[i].offset = 1;
     296            }
     297        }
     298    }
     299};
     300
    227301template<typename GradientAdapter>
    228 Gradient::ColorStopVector CSSGradientValue::computeStops(GradientAdapter& gradient, const CSSToLengthConversionData& conversionData, const RenderStyle& style, float maxLengthForRepeat)
     302Gradient::ColorStopVector CSSGradientValue::computeStops(GradientAdapter& gradientAdapter, const CSSToLengthConversionData& conversionData, const RenderStyle& style, float maxLengthForRepeat)
    229303{
    230304    if (m_gradientType == CSSDeprecatedLinearGradient || m_gradientType == CSSDeprecatedRadialGradient) {
     
    253327    Vector<GradientStop> stops(numStops);
    254328
    255     auto gradientStart = gradient.startPoint();
    256     auto gradientEnd = gradient.endPoint();
    257 
    258     auto gradientSize = gradientStart - gradientEnd;
    259     float gradientLength = gradientSize.diagonalLength();
     329    float gradientLength = gradientAdapter.gradientLength();
    260330
    261331    for (size_t i = 0; i < numStops; ++i) {
     
    283353                }
    284354                stops[i].offset = (gradientLength > 0) ? length / gradientLength : 0;
    285             } else {
     355            } else if (positionValue.isAngle())
     356                stops[i].offset = positionValue.floatValue(CSSPrimitiveValue::CSS_DEG) / 360;
     357            else {
    286358                ASSERT_NOT_REACHED();
    287359                stops[i].offset = 0;
     
    439511            numStops = 1;
    440512        } else {
    441             float maxExtent = gradient.maxExtent(maxLengthForRepeat, gradientLength);
     513            float maxExtent = gradientAdapter.maxExtent(maxLengthForRepeat, gradientLength);
    442514
    443515            size_t originalNumStops = numStops;
     
    487559    // If the gradient goes outside the 0-1 range, normalize it by moving the endpoints, and adjusting the stops.
    488560    if (stops.size() > 1 && (stops.first().offset < 0 || stops.last().offset > 1))
    489         gradient.normalizeStopsAndEndpointsOutsideRange(stops);
     561        gradientAdapter.normalizeStopsAndEndpointsOutsideRange(stops);
    490562   
    491563    Gradient::ColorStopVector result;
     
    13511423}
    13521424
    1353 Ref<Gradient> CSSConicGradientValue::createGradient(RenderElement&, const FloatSize&)
    1354 {
    1355     // FIXME: Implement.
    1356     return Gradient::create(Gradient::LinearData { });
     1425Ref<Gradient> CSSConicGradientValue::createGradient(RenderElement& renderer, const FloatSize& size)
     1426{
     1427    ASSERT(!size.isEmpty());
     1428
     1429    CSSToLengthConversionData conversionData(&renderer.style(), renderer.document().documentElement()->renderStyle(), &renderer.view());
     1430
     1431    FloatPoint centerPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), conversionData, size);
     1432    if (!m_firstX)
     1433        centerPoint.setX(size.width() / 2);
     1434    if (!m_firstY)
     1435        centerPoint.setY(size.height() / 2);
     1436
     1437    float angle = 0;
     1438    if (m_angle)
     1439        angle = m_angle->floatValue(CSSPrimitiveValue::CSS_DEG);
     1440
     1441    Gradient::ConicData data { centerPoint, angle };
     1442    ConicGradientAdapter adapter;
     1443    auto stops = computeStops(adapter, conversionData, renderer.style(), 1);
     1444
     1445    auto gradient = Gradient::create(WTFMove(data));
     1446    gradient->setSortedColorStops(WTFMove(stops));
     1447    return gradient;
    13571448}
    13581449
  • trunk/Source/WebCore/inspector/InspectorCanvas.cpp

    r234586 r235772  
    614614{
    615615    const auto& gradient = canvasGradient.gradient();
    616 
    617     String type = gradient.type() == Gradient::Type::Radial ? "radial-gradient"_s : "linear-gradient"_s;
     616   
     617    String type = gradient.type() == Gradient::Type::Radial ? "radial-gradient"_s : gradient.type() == Gradient::Type::Linear ? "linear-gradient"_s : "conic-gradient"_s;
    618618
    619619    auto parameters = JSON::ArrayOf<float>::create();
     
    632632            parameters->addItem(data.point1.y());
    633633            parameters->addItem(data.endRadius);
     634        },
     635        [&parameters] (const Gradient::ConicData& data) {
     636            parameters->addItem(data.point0.x());
     637            parameters->addItem(data.point0.y());
     638            parameters->addItem(data.angle);
    634639        }
    635640    );
  • trunk/Source/WebCore/page/Settings.yaml

    r235539 r235772  
    526526
    527527conicGradientsEnabled:
    528   initial: false
     528  initial: defaultConicGradient
    529529
    530530colorFilterEnabled:
  • trunk/Source/WebCore/page/SettingsDefaultValues.h

    r230679 r235772  
    104104static const bool defaultMediaEnabled = false;
    105105#endif
     106   
     107#if (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 120000) || (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101400) || PLATFORM(WATCHOS)
     108static const bool defaultConicGradient = true;
     109#else
     110static const bool defaultConicGradient = false;
     111#endif
     112   
    106113
    107114}
  • trunk/Source/WebCore/platform/graphics/Gradient.cpp

    r231565 r235772  
    4747}
    4848
     49Ref<Gradient> Gradient::create(ConicData&& data)
     50{
     51    return adoptRef(*new Gradient(WTFMove(data)));
     52}
     53
    4954Gradient::Gradient(LinearData&& data)
    5055    : m_data(WTFMove(data))
     
    5459
    5560Gradient::Gradient(RadialData&& data)
     61    : m_data(WTFMove(data))
     62{
     63    platformInit();
     64}
     65   
     66Gradient::Gradient(ConicData&& data)
    5667    : m_data(WTFMove(data))
    5768{
     
    7283        [] (const RadialData&) {
    7384            return Type::Radial;
     85        },
     86        [] (const ConicData&) {
     87            return Type::Conic;
    7488        }
    7589    );
     
    100114        },
    101115        [] (const RadialData&) {
     116        },
     117        [] (const ConicData&) {
    102118        }
    103119    );
     
    112128        [] (const RadialData& data) {
    113129            return data.point0.x() == data.point1.x() && data.point0.y() == data.point1.y() && data.startRadius == data.endRadius;
     130        },
     131        [] (const ConicData&) {
     132            return false;
    114133        }
    115134    );
     
    205224        float endRadius;
    206225        float aspectRatio;
     226        float angle;
    207227        GradientSpreadMethod spreadMethod;
    208228        AffineTransform gradientSpaceTransformation;
     
    224244            parameters.endRadius = 0;
    225245            parameters.aspectRatio = 0;
     246            parameters.angle = 0;
    226247            parameters.type = Type::Linear;
    227248        },
     
    232253            parameters.endRadius = data.endRadius;
    233254            parameters.aspectRatio = data.aspectRatio;
     255            parameters.angle = 0;
    234256            parameters.type = Type::Radial;
     257        },
     258        [&parameters] (const ConicData& data) {
     259            parameters.point0 = data.point0;
     260            parameters.point1 = {0, 0};
     261            parameters.startRadius = 0;
     262            parameters.endRadius = 0;
     263            parameters.aspectRatio = 0;
     264            parameters.angle = data.angle;
     265            parameters.type = Type::Conic;
    235266        }
    236267    );
  • trunk/Source/WebCore/platform/graphics/Gradient.h

    r225036 r235772  
    8686        float aspectRatio; // For elliptical gradient, width / height.
    8787    };
     88   
     89    struct ConicData {
     90        FloatPoint point0;
     91        float angle;
     92    };
    8893
    89     using Data = Variant<LinearData, RadialData>;
     94    using Data = Variant<LinearData, RadialData, ConicData>;
    9095
    91     enum class Type { Linear, Radial };
     96    enum class Type { Linear, Radial, Conic };
    9297
    9398    static Ref<Gradient> create(LinearData&&);
    9499    static Ref<Gradient> create(RadialData&&);
     100    static Ref<Gradient> create(ConicData&&);
    95101
    96102    WEBCORE_EXPORT ~Gradient();
     
    134140    Gradient(LinearData&&);
    135141    Gradient(RadialData&&);
     142    Gradient(ConicData&&);
    136143
    137144    PlatformGradient platformGradient();
  • trunk/Source/WebCore/platform/graphics/cg/GradientCG.cpp

    r225036 r235772  
    128128            if (needScaling)
    129129                CGContextRestoreGState(platformContext);
     130        },
     131        [&] (const ConicData& data) {
     132#if (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 120000) || (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101400) || PLATFORM(WATCHOS)
     133            CGContextSaveGState(platformContext);
     134            CGContextTranslateCTM(platformContext, data.point0.x(), data.point0.y());
     135            CGContextRotateCTM(platformContext, (CGFloat)-M_PI_2);
     136            CGContextTranslateCTM(platformContext, -data.point0.x(), -data.point0.y());
     137            CGContextDrawConicGradient(platformContext, platformGradient(), data.point0, data.angle);
     138            CGContextRestoreGState(platformContext);
     139#else
     140            UNUSED_PARAM(data);
     141#endif
    130142        }
    131143    );
  • trunk/Source/WebKit/ChangeLog

    r235769 r235772  
     12018-09-06  Megan Gardner  <megan_gardner@apple.com>
     2
     3        Add Support for Conic Gradients
     4        https://bugs.webkit.org/show_bug.cgi?id=189329
     5        <rdar://problem/21444701>
     6
     7        Reviewed by Simon Fraser.
     8
     9        Connect up web preferences to allow conic gradients to be turned on in the
     10        experimental features menu.
     11
     12        * Shared/WebPreferences.yaml:
     13
    1142018-09-06  Wenson Hsieh  <wenson_hsieh@apple.com>
    215
  • trunk/Source/WebKit/Shared/WebPreferences.yaml

    r235683 r235772  
    11491149  category: experimental
    11501150
     1151ConicGradientsEnabled:
     1152    type: bool
     1153    defaultValue: DEFAULT_CONIC_GRADIENT_ENABLED
     1154    humanReadableName: "CSS Conic Gradient"
     1155    humanReadableDescription: "Support for CSS Conic Gradients"
     1156    category: experimental
     1157
    11511158ImageBitmapOffscreenCanvasEnabled:
    11521159  type: bool
  • trunk/Source/WebKit/Shared/WebPreferencesDefaultValues.h

    r235512 r235772  
    210210#endif
    211211
     212#if (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 120000) || (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101400) || PLATFORM(WATCHOS)
     213#define DEFAULT_CONIC_GRADIENT_ENABLED true
     214#else
     215#define DEFAULT_CONIC_GRADIENT_ENABLED false
     216#endif
     217
    212218bool defaultPassiveTouchListenersAsDefaultOnDocument();
    213219bool defaultCustomPasteboardDataEnabled();
Note: See TracChangeset for help on using the changeset viewer.