Add support for colored and non-colored Patterns

Frameworks/CoreGraphics/CGContext.mm

@@ -1770,8 +1770,10 @@ static CGImageRef __CGContextCreateRenderableImage(CGImageRef image) {
 #pragma region Drawing Parameters - Stroke / Fill Patterns
 
 template <typename ContextStageLambda> // Takes the form HRESULT(*)(CGContextRef)
-static HRESULT _CreatePatternBrush(
-    CGContextRef context, CGPatternRef pattern, const CGFloat* components, ID2D1BitmapBrush1** brush, ContextStageLambda&& contextStage) {
+static HRESULT _CreatePatternBrush(CGContextRef context,
+                                   CGPatternRef pattern,
+                                   ID2D1BitmapBrush1** brush,
+                                   ContextStageLambda&& contextStage) {
     // TODO #1592: change to support grayscale (masks) after dustins change.
     woc::unique_cf<CGColorSpaceRef> colorspace{ CGColorSpaceCreateDeviceRGB() };
 
@@ -1781,20 +1783,23 @@ static HRESULT _CreatePatternBrush(
 
     size_t bitsPerComponent = 8;
     size_t bytesPerRow = 4 * tileSize.size.width;
-    CGBitmapInfo bitmapInfo = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Big;
+    CGBitmapInfo bitmapInfo = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrderDefault;
 
     woc::unique_cf<CGContextRef> patternContext{ CGBitmapContextCreate(
         nullptr, tileSize.size.width, tileSize.size.height, bitsPerComponent, bytesPerRow, colorspace.get(), bitmapInfo) };
     RETURN_HR_IF_NULL(E_UNEXPECTED, patternContext);
 
+    // Determine if this pattern is a colored pattern (the coloring is specified in the pattern callback) or if it is stencil pattern (the
+    // color is set outside and not within the pattern callback)
+    bool isColored = _CGPatternIsColored(pattern);
+
     // Stage the drawing context
-    RETURN_IF_FAILED(std::forward<ContextStageLambda>(contextStage)(patternContext.get()));
+    RETURN_IF_FAILED(std::forward<ContextStageLambda>(contextStage)(patternContext.get(), isColored));
 
     // Now we ask the user to draw
     _CGPatternIssueCallBack(patternContext.get(), pattern);
 
     // Get the image out of it
-
     woc::unique_cf<CGImageRef> bitmapTiledimage{ CGBitmapContextCreateImage(patternContext.get()) };
     woc::unique_cf<CGImageRef> tileImage{ __CGContextCreateRenderableImage(bitmapTiledimage.get()) };
     RETURN_HR_IF_NULL(E_UNEXPECTED, tileImage);
@@ -1848,9 +1853,18 @@ void CGContextSetFillPattern(CGContextRef context, CGPatternRef pattern, const C
     }
 
     ComPtr<ID2D1BitmapBrush1> bitmapBrush;
-    FAIL_FAST_IF_FAILED(_CreatePatternBrush(context, pattern, components, &bitmapBrush, [&](CGContextRef drawingContext) {
+    FAIL_FAST_IF_FAILED(_CreatePatternBrush(context, pattern, &bitmapBrush, [&](CGContextRef drawingContext, bool isColored) {
         CGContextSetFillColorSpace(drawingContext, context->FillColorSpace());
-        CGContextSetFillColor(drawingContext, components);
+        if (isColored) {
+            // It's a colored pattern, the color is specified by the pattern callback.
+            // The 'components' are alpha value.
+            CGContextSetAlpha(drawingContext, components[0]);
+        } else {
+            // It is a stencil pattern, we should stage the context's color
+            // The 'components' are the color for the stencil.
+            CGContextSetFillColor(drawingContext, components);
+        }
+
         return S_OK;
     }));
     // set the fill brush
@@ -1879,9 +1893,17 @@ void CGContextSetStrokePattern(CGContextRef context, CGPatternRef pattern, const
     }
 
     ComPtr<ID2D1BitmapBrush1> bitmapBrush;
-    FAIL_FAST_IF_FAILED(_CreatePatternBrush(context, pattern, components, &bitmapBrush, [&](CGContextRef drawingContext) {
+    FAIL_FAST_IF_FAILED(_CreatePatternBrush(context, pattern, &bitmapBrush, [&](CGContextRef drawingContext, bool isColored) {
         CGContextSetStrokeColorSpace(drawingContext, context->StrokeColorSpace());
-        CGContextSetStrokeColor(drawingContext, components);
+        if (isColored) {
+            // It's a colored pattern, the color is specified by the pattern callback.
+            // The 'components' are alpha value.
+            CGContextSetAlpha(drawingContext, components[0]);
+        } else {
+            // It is a stencil pattern, we should stage the context's color
+            // The 'components' are the color for the stencil.
+            CGContextSetStrokeColor(drawingContext, components);
+        }
         return S_OK;
     }));
     // set the stroke brush

Frameworks/CoreGraphics/CGPattern.mm

@@ -233,3 +233,8 @@ CGRect _CGPatternGetFinalPatternSize(CGPatternRef pattern) {
     RETURN_RESULT_IF_NULL(pattern, CGRectNull);
     return { CGPointZero, { ((CGPattern*)pattern)->xStep, ((CGPattern*)pattern)->yStep } };
 }
+
+bool _CGPatternIsColored(CGPatternRef pattern) {
+    FAIL_FAST_IF_NULL(pattern);
+    return ((CGPattern*)pattern)->isColored;
+}

Frameworks/include/CGPatternInternal.h

@@ -50,3 +50,10 @@ CGAffineTransform _CGPatternGetTransformation(CGPatternRef pattern);
 * Get the final size of the pattern tile (after xStep and xStep has been applied).
 */
 CGRect _CGPatternGetFinalPatternSize(CGPatternRef pattern);
+
+/*
+* Get the pattern colored value.
+* If it is colored, then we have a colored pattern has inherent color,
+* if it's false then we have a stencil pattern does not have inherent color.
+*/
+bool _CGPatternIsColored(CGPatternRef pattern);

build/Tests/UnitTests/CoreGraphics.Drawing/CoreGraphics.Drawing.UnitTests.vcxproj

@@ -251,6 +251,7 @@
     <ClangCompile Include="$(StarboardBasePath)\tests\unittests\CoreGraphics.Drawing\CGContextDrawing_ImageMaskTests.cpp" />
     <ClangCompile Include="$(StarboardBasePath)\tests\unittests\CoreGraphics.Drawing\CGContextDrawing_GradientTests.cpp" />
     <ClangCompile Include="$(StarboardBasePath)\tests\unittests\CoreGraphics.Drawing\CGContextDrawing_ImageDrawingTests.cpp" />
+    <ClangCompile Include="$(StarboardBasePath)\tests\unittests\CoreGraphics.Drawing\CGContextDrawing_PatternTests.cpp" />
     <ClangCompile Include="$(StarboardBasePath)\tests\unittests\CoreGraphics.Drawing\CGPathDrawingTests.cpp" />
     <ClangCompile Include="$(StarboardBasePath)\tests\unittests\CoreGraphics.Drawing\DrawingTest.cpp" />
     <ClangCompile Include="$(StarboardBasePath)\tests\unittests\CoreGraphics.drawing\ImageComparison.cpp" />

tests/UnitTests/CoreGraphics.drawing/CGContextDrawing_PatternTests.cpp

@@ -0,0 +1,178 @@
+//******************************************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+//******************************************************************************
+
+#include "DrawingTest.h"
+
+#pragma region Stencil Pattern
+
+static void drawStencilStar(void* info, CGContextRef context) {
+    double r = 0.8 * 16 / 2;
+    double theta = 2 * M_PI * (2.0 / 5.0); // 144 degrees
+
+    CGContextTranslateCTM(context, 16 / 2, 16 / 2);
+
+    CGContextMoveToPoint(context, 0, r);
+    for (int i = 1; i < 5; i++) {
+        CGContextAddLineToPoint(context, r * sin(i * theta), r * cos(i * theta));
+    }
+    CGContextClosePath(context);
+    CGContextFillPath(context);
+}
+
+static void drawStencilBox(void* info, CGContextRef context) {
+    CGContextFillRect(context, CGRectMake(0, 0, 8, 8));
+}
+
+struct PatternCallback {
+    const char* name;
+    CGPatternDrawPatternCallback callback;
+};
+
+struct StencilColor {
+    const char* name;
+    float color[4];
+};
+
+PatternCallback stencilPatternCallback[] = { { "drawStencilStar", &drawStencilStar }, { "drawStencilBox", &drawStencilBox } };
+
+StencilColor stencilColors[] = { { "orange", { 1, 0.64, 0, 1 } }, { "gold", { 1, 0.84, 0, 1 } },    { "red", { 1, 0, 0, 1 } },
+                                 { "green", { 0, 1, 0, 1 } },     { "blue", { 0, 0, 1, 1 } },       { "cyan", { 0, 1, 1, 1 } },
+                                 { "teal", { 0, 0.5, 0.5, 1 } },  { "purple", { 0.5, 0, 0.5, 1 } }, { "Maroon", { 0.5, 0, 0, 1 } } };
+
+int patternsizes[] = { 1, 2, 4, 8, 13, 10, 16, 20, 32, 128, 241 };
+
+//<PatternCallback,StencilColor,pattern size>
+class CGPatternStencil : public WhiteBackgroundTest<>,
+                         public ::testing::WithParamInterface<::testing::tuple<PatternCallback, StencilColor, int>> {
+    CFStringRef CreateOutputFilename() {
+        PatternCallback stencil = ::testing::get<0>(GetParam());
+        StencilColor stencilColor = ::testing::get<1>(GetParam());
+        int size = ::testing::get<2>(GetParam());
+
+        return CFStringCreateWithFormat(nullptr,
+                                        nullptr,
+                                        CFSTR("TestImage.CGContext.CGPatternStencil.%s.%s.%d.png"),
+                                        stencil.name,
+                                        stencilColor.name,
+                                        size);
+    }
+};
+
+TEST_P(CGPatternStencil, DrawStencils) {
+    CGPatternDrawPatternCallback callback = ::testing::get<0>(GetParam()).callback;
+    const CGFloat* stencilColor = ::testing::get<1>(GetParam()).color;
+    int size = ::testing::get<2>(GetParam());
+
+    CGContextRef context = GetDrawingContext();
+    CGRect bounds = GetDrawingBounds();
+
+    static const CGPatternCallbacks callbacks = { 0, callback, NULL };
+
+    CGColorSpaceRef baseSpace = CGColorSpaceCreateDeviceRGB();
+    CGColorSpaceRef patternSpace = CGColorSpaceCreatePattern(baseSpace);
+    CGContextSetFillColorSpace(context, patternSpace);
+    CGColorSpaceRelease(patternSpace);
+    CGColorSpaceRelease(baseSpace);
+
+    CGPatternRef pattern = CGPatternCreate(
+        NULL, CGRectMake(0, 0, size, size), CGAffineTransformIdentity, size, size, kCGPatternTilingConstantSpacing, false, &callbacks);
+
+    CGContextSetFillPattern(context, pattern, stencilColor);
+    CGPatternRelease(pattern);
+    CGContextFillRect(context, bounds);
+}
+
+INSTANTIATE_TEST_CASE_P(CGPatternTests,
+                        CGPatternStencil,
+                        ::testing::Combine(::testing::ValuesIn(stencilPatternCallback),
+                                           ::testing::ValuesIn(stencilColors),
+                                           ::testing::ValuesIn(patternsizes)));
+
+#pragma endregion Stencil Pattern
+
+#pragma region Colored Pattern
+
+void drawColoredPatternMultiSquare(void* info, CGContextRef context) {
+    CGFloat subunit = 5; // the pattern cell itself is 16 by 18
+
+    CGRect myRect1 = { { 0, 0 }, { subunit, subunit } }, myRect2 = { { subunit, subunit }, { subunit, subunit } },
+           myRect3 = { { 0, subunit }, { subunit, subunit } }, myRect4 = { { subunit, 0 }, { subunit, subunit } };
+
+    CGContextSetRGBFillColor(context, 0, 0, 1, 0.5);
+    CGContextFillRect(context, myRect1);
+    CGContextSetRGBFillColor(context, 1, 0, 0, 0.5);
+    CGContextFillRect(context, myRect2);
+    CGContextSetRGBFillColor(context, 0, 1, 0, 0.5);
+    CGContextFillRect(context, myRect3);
+    CGContextSetRGBFillColor(context, .5, 0, .5, 0.5);
+    CGContextFillRect(context, myRect4);
+}
+
+PatternCallback ColoredPatternCallback[] = { { "drawColoredPatternMultiSquare", &drawColoredPatternMultiSquare } };
+
+//<PatternCallback,alpha,pattern size>
+class CGPatternColored : public WhiteBackgroundTest<>,
+                         public ::testing::WithParamInterface<::testing::tuple<PatternCallback, CGFloat, int>> {
+    CFStringRef CreateOutputFilename() {
+        PatternCallback pattern = ::testing::get<0>(GetParam());
+        CGFloat alpha = ::testing::get<1>(GetParam());
+        int size = ::testing::get<2>(GetParam());
+
+        return CFStringCreateWithFormat(nullptr,
+                                        nullptr,
+                                        CFSTR("TestImage.CGContext.CGPatternColored.%s.size.%d.A%1.01f.png"),
+                                        pattern.name,
+                                        size,
+                                        alpha);
+    }
+};
+
+TEST_P(CGPatternColored, ColoredSquare) {
+    CGPatternDrawPatternCallback callback = ::testing::get<0>(GetParam()).callback;
+    CGFloat alpha = ::testing::get<1>(GetParam());
+    int size = ::testing::get<2>(GetParam());
+
+    CGContextRef context = GetDrawingContext();
+    CGRect bounds = GetDrawingBounds();
+    static const CGPatternCallbacks callbacks = { 0, callback, NULL };
+
+    CGColorSpaceRef patternSpace = CGColorSpaceCreatePattern(NULL);
+    CGContextSetFillColorSpace(context, patternSpace);
+    CGColorSpaceRelease(patternSpace);
+
+    CGPatternRef pattern = CGPatternCreate(NULL,
+                                           CGRectMake(0, 0, size / 2, size / 2),
+                                           CGAffineTransformMake(1, 0, 0, 1, 0, 0),
+                                           size,
+                                           size,
+                                           kCGPatternTilingConstantSpacing,
+                                           true,
+                                           &callbacks);
+
+    CGContextSetFillPattern(context, pattern, &alpha);
+    CGPatternRelease(pattern);
+    CGContextFillRect(context, bounds);
+}
+
+static CGFloat alphas[] = { 0.0f, 0.25f, 0.35f, 0.42f, 0.5f, 0.75f, 0.85f, 0.95f, 1.f };
+
+INSTANTIATE_TEST_CASE_P(CGPatternTests,
+                        CGPatternColored,
+                        ::testing::Combine(::testing::ValuesIn(ColoredPatternCallback),
+                                           ::testing::ValuesIn(alphas),
+                                           ::testing::ValuesIn(patternsizes)));
+
+#pragma endregion Colored Pattern