#include "graphics.h"

/* Copyright (C) 2003-2013 Runtime Revolution Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License v3 as published by the Free

Software Foundation.

LiveCode is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with LiveCode. If not see <http://www.gnu.org/licenses/>. */

#include "graphics-internal.h"

#include <SkCanvas.h>

#include <SkDevice.h>

#include <SkPaint.h>

#include <SkBitmap.h>

#include <SkShader.h>

#include <SkColorShader.h>

#include <SkLayerDrawLooper.h>

#include <SkBlurMaskFilter.h>

#include <SkColorFilter.h>

#include <SkDevice.h>

#include <SkImageFilter.h>

#include <SkOffsetImageFilter.h>

#include <SkBlurImageFilter.h>

#include <SkTypeface.h>

#include <SkColorPriv.h>

#include <SkUtils.h>

#include <SkStippleMaskFilter.h>

#include <time.h>

////////////////////////////////////////////////////////////////////////////////

struct MCGIRectangle

{

int32_t left;

int32_t top;

int32_t right;

int32_t bottom;

};

MCGIRectangle MCGIRectangleMake(int32_t left, int32_t top, int32_t right, int32_t bottom)

{

MCGIRectangle r;

r . left = left;

r . top = top;

r . right = right;

r . bottom = bottom;

return r;

}

MCGIRectangle MCGRectangleComputeHull(const MCGRectangle& self)

{

return MCGIRectangleMake((int)floor(self . origin . x), (int)floor(self . origin . y), (int)ceil(self . origin . x + self . size . width), (int)ceil(self . origin . y + self . size . height));

}

MCGIRectangle MCGIRectangleUnion(const MCGIRectangle& left, const MCGIRectangle& right)

{

return MCGIRectangleMake(SkMin32(left . left, right . left), SkMin32(left . top, right . top), SkMax32(left . right, right . right), SkMax32(left . bottom, right . bottom));

}

MCGIRectangle MCGIRectangleIntersect(const MCGIRectangle& left, const MCGIRectangle& right)

{

return MCGIRectangleMake(SkMax32(left . left, right . left), SkMax32(left . top, right . top), SkMin32(left . right, right . right), SkMin32(left . bottom, right . bottom));

}

MCGIRectangle MCGIRectangleOffset(const MCGIRectangle& self, int32_t dx, int32_t dy)

{

return MCGIRectangleMake(self . left + dx, self . top + dy, self . right + dx, self . bottom + dy);

}

MCGIRectangle MCGIRectangleExpand(const MCGIRectangle& self, int32_t dx, int32_t dy)

{

return MCGIRectangleMake(self . left - dx, self . top - dy, self . right + dx, self . bottom + dy);

}

////////////////////////////////////////////////////////////////////////////////

static void MCGContextStateDestroy(MCGContextStateRef self)

{

if (self != NULL)

{

if (self -> fill_pattern != NULL)

MCGPatternRelease(self -> fill_pattern);

if (self -> fill_gradient != NULL)

MCGGradientRelease(self -> fill_gradient);

if (self -> stroke_pattern != NULL)

MCGPatternRelease(self -> stroke_pattern);

if (self -> stroke_gradient != NULL)

MCGGradientRelease(self -> stroke_gradient);

MCGDashesRelease(self -> stroke_attr . dashes);

}

MCMemoryDelete(self);

}

static bool MCGContextStateCreate(MCGContextStateRef& r_state)

{

bool t_success;

t_success = true;

__MCGContextState *t_state;

t_state = NULL;

if (t_success)

t_success = MCMemoryNew(t_state);

if (t_success)

{

t_state -> opacity = 1.0f;

t_state -> blend_mode = kMCGBlendModeSourceOver;

t_state -> flatness = 0.0f;

t_state -> should_antialias = false;

t_state -> fill_color = MCGColorMakeRGBA(0.0f, 0.0f, 0.0f, 1.0f);

t_state -> fill_opacity = 0.0f;

t_state -> fill_rule = kMCGFillRuleNonZero;

t_state -> fill_pattern = NULL;

t_state -> fill_gradient= NULL;

t_state -> fill_style = kMCGPaintStyleOpaque;

t_state -> stroke_color = MCGColorMakeRGBA(0.0f, 0.0f, 0.0f, 1.0f);

t_state -> stroke_opacity = 0.0f;

t_state -> stroke_pattern = NULL;

t_state -> stroke_gradient= NULL;

t_state -> stroke_attr . width = 0.0f;

t_state -> stroke_attr . join_style = kMCGJoinStyleBevel;

t_state -> stroke_attr . cap_style = kMCGCapStyleButt;

t_state -> stroke_attr . miter_limit = 0.0f;

t_state -> stroke_attr . dashes = NULL;

t_state -> stroke_style = kMCGPaintStyleOpaque;

t_state -> is_layer_begin_pt = false;

t_state -> parent = NULL;

}

if (t_success)

r_state = t_state;

else

MCGContextStateDestroy(t_state);

return t_success;

}

static bool MCGContextStateCopy(MCGContextStateRef p_state, MCGContextStateRef& r_new_state)

{

bool t_success;

t_success = true;

__MCGContextState *t_state;

t_state = NULL;

if (t_success)

t_success = MCMemoryNew(t_state);

if (t_success)

{

t_state -> opacity = p_state -> opacity;

t_state -> blend_mode = p_state -> blend_mode;

t_state -> flatness = p_state -> flatness;

t_state -> should_antialias = p_state -> should_antialias;

t_state -> fill_color = p_state -> fill_color;

t_state -> fill_opacity = p_state -> fill_opacity;

t_state -> fill_rule = p_state -> fill_rule;

t_state -> fill_pattern = MCGPatternRetain(p_state -> fill_pattern);

t_state -> fill_gradient = MCGGradientRetain(p_state -> fill_gradient);

t_state -> fill_style = p_state -> fill_style;

t_state -> stroke_color = p_state -> stroke_color;

t_state -> stroke_opacity = p_state -> stroke_opacity;

t_state -> stroke_pattern = MCGPatternRetain(p_state -> stroke_pattern);

t_state -> stroke_gradient = MCGGradientRetain(p_state -> stroke_gradient);

t_state -> stroke_attr . width = p_state -> stroke_attr . width;

t_state -> stroke_attr . join_style = p_state -> stroke_attr . join_style;

t_state -> stroke_attr . cap_style = p_state -> stroke_attr . cap_style;

t_state -> stroke_attr . miter_limit = p_state -> stroke_attr . miter_limit;

t_state -> stroke_attr . dashes = MCGDashesRetain(p_state -> stroke_attr . dashes);

t_state -> stroke_style = p_state -> stroke_style;

t_state -> is_layer_begin_pt = false;

t_state -> parent = NULL;

}

if (t_success)

r_new_state = t_state;

else

MCGContextStateDestroy(t_state);

return t_success;

}

////////////////////////////////////////////////////////////////////////////////

static void MCGContextLayerDestroy(MCGContextLayerRef self)

{

if (self == nil)

return;

self -> canvas -> unref();

MCMemoryDelete(self);

}

static bool MCGContextLayerCreate(SkCanvas *p_canvas, MCGContextLayerRef& r_layer)

{

bool t_success;

t_success = true;

__MCGContextLayer *t_layer;

t_layer = NULL;

if (t_success)

t_success = MCMemoryNew(t_layer);

if (t_success)

{

p_canvas -> ref();

t_layer -> canvas = p_canvas;

t_layer -> nesting = 0;

t_layer -> parent = nil;

}

if (t_success)

r_layer = t_layer;

else

MCGContextLayerDestroy(t_layer);

return t_success;

}

////////////////////////////////////////////////////////////////////////////////

static bool MCGContextPushState(MCGContextRef self)

{

bool t_success;

t_success = true;

MCGContextStateRef t_state;

if (t_success)

t_success = MCGContextStateCopy(self -> state, t_state);

if (t_success)

{

t_state -> parent = self -> state;

self -> state = t_state;

}

return t_success;

}

static bool MCGContextPopState(MCGContextRef self)

{

bool t_success;

t_success = true;

if (t_success)

{

MCGContextStateRef t_parent_state;

t_parent_state = self -> state -> parent;

MCGContextStateDestroy(self -> state);

self -> state = t_parent_state;

}

return t_success;

}

////////////////////////////////////////////////////////////////////////////////

static void MCGContextDestroy(MCGContextRef self)

{

if (self != NULL)

{

while (self -> state != NULL)

{

MCGContextStateRef t_tmp_state;

t_tmp_state = self -> state -> parent;

MCGContextStateDestroy(self -> state);

self -> state = t_tmp_state;

}

while(self -> layer != NULL)

{

MCGContextLayerRef t_tmp_layer;

t_tmp_layer = self -> layer -> parent;

MCGContextLayerDestroy(self -> layer);

self -> layer = t_tmp_layer;

}

if (self -> path != NULL)

MCGPathRelease(self -> path);

}

MCMemoryDelete(self);

}

static bool MCGContextCreateWithBitmap(SkBitmap& p_bitmap, MCGContextRef& r_context)

{

bool t_success;

t_success = true;

__MCGContext *t_context;

t_context = NULL;

if (t_success)

t_success = MCMemoryNew(t_context);

SkCanvas *t_canvas;

t_canvas = nil;

if (t_success)

{

t_canvas = new SkCanvas(p_bitmap);

t_success = t_canvas != NULL;

}

if (t_success)

t_success = MCGContextLayerCreate(t_canvas, t_context -> layer);

if (t_success)

t_success = MCGContextStateCreate(t_context -> state);

if (t_success)

{

//t_context -> width = p_bitmap . width();

//t_context -> height = p_bitmap . height();

t_context -> references = 1;

t_context -> path = NULL;

t_context -> is_valid = true;

}

if (t_success)

{

r_context = t_context;

}

else

MCGContextDestroy(t_context);

if (t_canvas != nil)

t_canvas -> unref();

return t_success;

}

bool MCGContextCreate(uint32_t p_width, uint32_t p_height, bool p_alpha, MCGContextRef& r_context)

{

SkBitmap t_bitmap;

t_bitmap . setConfig(SkBitmap::kARGB_8888_Config, p_width, p_height);

if (!p_alpha)

t_bitmap . setAlphaType(kOpaque_SkAlphaType);

else

t_bitmap . setAlphaType(kPremul_SkAlphaType);

if (t_bitmap . allocPixels())

return MCGContextCreateWithBitmap(t_bitmap, r_context);

else

return false;

}

bool MCGContextCreateWithRaster(const MCGRaster& p_raster, MCGContextRef& r_context)

{

SkBitmap t_bitmap;

if (MCGRasterToSkBitmap(p_raster, kMCGPixelOwnershipTypeBorrow, t_bitmap))

return MCGContextCreateWithBitmap(t_bitmap, r_context);

else

return false;

}

bool MCGContextCreateWithPixels(uint32_t p_width, uint32_t p_height, uint32_t p_stride, void *p_pixels, bool p_alpha, MCGContextRef& r_context)

{

SkBitmap t_bitmap;

t_bitmap . setConfig(SkBitmap::kARGB_8888_Config, p_width, p_height, p_stride);

if (!p_alpha)

t_bitmap . setAlphaType(kOpaque_SkAlphaType);

else

t_bitmap . setAlphaType(kPremul_SkAlphaType);

t_bitmap . setPixels(p_pixels);

return MCGContextCreateWithBitmap(t_bitmap, r_context);

}

void *MCGContextGetPixelPtr(MCGContextRef context)

{

MCGContextLayerRef t_layer;

t_layer = context -> layer;

while(t_layer -> parent != nil)

t_layer = t_layer -> parent;

const SkBitmap& t_bitmap = t_layer -> canvas -> getTopDevice() -> accessBitmap(false);

return t_bitmap . getPixels();

}

uint32_t MCGContextGetWidth(MCGContextRef context)

{

MCGContextLayerRef t_layer;

t_layer = context -> layer;

while(t_layer -> parent != nil)

t_layer = t_layer -> parent;

const SkBitmap& t_bitmap = t_layer -> canvas -> getTopDevice() -> accessBitmap(false);

return t_bitmap . width();

}

uint32_t MCGContextGetHeight(MCGContextRef context)

{

MCGContextLayerRef t_layer;

t_layer = context -> layer;

while(t_layer -> parent != nil)

t_layer = t_layer -> parent;

const SkBitmap& t_bitmap = t_layer -> canvas -> getTopDevice() -> accessBitmap(false);

return t_bitmap . height();

}

MCGContextRef MCGContextRetain(MCGContextRef self)

{

if (self != NULL)

self -> references++;

return self;

}

void MCGContextRelease(MCGContextRef self)

{

if (self != NULL)

{

self -> references--;

if (self -> references <= 0)

MCGContextDestroy(self);

}

}

////////////////////////////////////////////////////////////////////////////////

// Returns whether the current context context is valid. If an error

// occurs when calling any method on a context context, it will become

// invalid and all further operations will be no-ops.

bool MCGContextIsValid(MCGContextRef self)

{

return self != NULL && self -> is_valid;

}

////////////////////////////////////////////////////////////////////////////////

// Graphics state operations

void MCGContextSave(MCGContextRef self)

{

if (!MCGContextIsValid(self))

return;

bool t_success;

t_success = true;

if (t_success)

{

// we use skia to manage the clip and matrix between states, everything else is held in the state directly

self -> layer -> canvas -> save((SkCanvas::SaveFlags) (SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag));

t_success = MCGContextPushState(self);

}

self -> is_valid = t_success;

}

void MCGContextRestore(MCGContextRef self)

{

if (!MCGContextIsValid(self))

return;

bool t_success;

t_success = true;

if (t_success)

t_success = self -> state -> parent != NULL;

// make sure we don't restore to a state before the current layer was begun

if (t_success)

if (!self -> state -> parent -> is_layer_begin_pt)

t_success = MCGContextPopState(self);

// we use skia to maintain a state's clip and transform, so calling restore ensures that the parent state's clip and CTM are restored properly

if (t_success)

self -> layer -> canvas -> restore();

self -> is_valid = t_success;

}

////////////////////////////////////////////////////////////////////////////////

// General attributes

void MCGContextSetFlatness(MCGContextRef self, MCGFloat p_flatness)

{

if (!MCGContextIsValid(self))

return;

self -> state -> flatness = p_flatness;

}

void MCGContextSetShouldAntialias(MCGContextRef self, bool p_should_antialias)

{

if (!MCGContextIsValid(self))

return;

self -> state -> should_antialias = p_should_antialias;

}

////////////////////////////////////////////////////////////////////////////////

// Layer attributes and manipulation - bitmap effect options would be added here also.

// Now replay the clip from the parent layer.

class CanvasClipVisitor: public SkCanvas::ClipVisitor

{

public:

CanvasClipVisitor(SkCanvas *p_target_canvas)

{

m_target_canvas = p_target_canvas;

}

void clipRect(const SkRect& p_rect, SkRegion::Op p_op, bool p_antialias)

{

m_target_canvas -> clipRect(p_rect, p_op, false);

}

void clipPath(const SkPath& p_path, SkRegion::Op p_op, bool p_antialias)

{

m_target_canvas -> clipPath(p_path, p_op, false);

}

private:

SkCanvas *m_target_canvas;

};

void MCGContextBegin(MCGContextRef self, bool p_need_layer)

{

if (!MCGContextIsValid(self))

return;

// If we are blending sourceOver

if (!p_need_layer && self -> state -> blend_mode == kMCGBlendModeSourceOver && self -> state -> opacity == 1.0)

{

//MCGContextSave(self);

self -> layer -> nesting += 1;

return;

}

// Fetch the bounds of the current clip in device co-ords and if the

// clip is empty, then just increase the nesting level.

SkIRect t_device_clip;

if (!self -> layer -> canvas -> getClipDeviceBounds(&t_device_clip))

{

//MCGContextSave(self);

self -> layer -> nesting += 1;

return;

}

// Fetch the total matrix of the canvas.

SkMatrix t_device_matrix;

t_device_matrix = self -> layer -> canvas -> getTotalMatrix();

// Create a suitable bitmap.

SkBitmap t_new_bitmap;

t_new_bitmap . setConfig(SkBitmap::kARGB_8888_Config, t_device_clip . width(), t_device_clip . height());

t_new_bitmap . setAlphaType(kPremul_SkAlphaType);

if (!t_new_bitmap . allocPixels())

{

self -> is_valid = false;

return;

}

// Clear the pixel buffer.

memset(t_new_bitmap . getPixels(), 0, t_new_bitmap . rowBytes() * t_new_bitmap . height());

// We now create a canvas the same size as the device clip.

SkCanvas *t_new_canvas;

t_new_canvas = new SkCanvas(t_new_bitmap);

if (t_new_canvas == nil)

{

self -> is_valid = false;

return;

}

SkAutoUnref t_canvas_au(t_new_canvas);

// Next translate the canvas by the translation factor of the matrix.

t_new_canvas -> translate(-t_device_clip . x(), -t_device_clip . y());

// Replay the clip.

CanvasClipVisitor t_clip_visitor(t_new_canvas);

self -> layer -> canvas -> replayClips(&t_clip_visitor);

// Set the matrix.

t_new_canvas -> concat(t_device_matrix);

// Make a save point in the new canvas.

t_new_canvas -> save();

// Set the current state as the layer being pt.

self -> state -> is_layer_begin_pt = true;

// Push the current state onto the attribute stack.

MCGContextPushState(self);

self -> state -> opacity = 1.0;

self -> state -> blend_mode = kMCGBlendModeSourceOver;

// Now create the layer.

MCGContextLayerRef t_new_layer;

if (!MCGContextLayerCreate(t_new_canvas, t_new_layer))

{

self -> is_valid = false;

return;

}

t_new_layer -> parent = self -> layer;

t_new_layer -> origin_x = t_device_clip . x();

t_new_layer -> origin_y = t_device_clip . y();

t_new_layer -> has_effects = false;

self -> layer = t_new_layer;

}

#if 0

static MCGIRectangle compute_glow_clip(const MCGGlowEffect& self, const MCGIRectangle& p_shape, const MCGIRectangle& p_clip, const MCGAffineTransform& p_transform)

{

MCGSize t_radii;

t_radii . width = self . size;

t_radii . height = self . size;

MCGSize t_transformed_radii;

t_transformed_radii = MCGSizeApplyAffineTransform(t_radii, p_transform);

return MCGIRectangleExpand(MCGIRectangleIntersect(p_shape, p_clip), ceil(t_transformed_radii . width), ceil(t_transformed_radii . height));

}

static MCGIRectangle compute_shadow_clip(const MCGShadowEffect& self, const MCGIRectangle& p_shape, const MCGIRectangle& p_clip, const MCGAffineTransform& p_transform)

{

MCGSize t_offset;

t_offset . width = self . x_offset; //self . distance * cos(self . angle * M_PI / 180.0);

t_offset . height = self . y_offset; //self . distance * sin(self . angle * M_PI / 180.0);

MCGSize t_transformed_offset;

t_transformed_offset = MCGSizeApplyAffineTransform(t_offset, p_transform);

MCGSize t_radii;

t_radii . width = self . size;

t_radii . height = self . size;

MCGSize t_transformed_radii;

t_transformed_radii = MCGSizeApplyAffineTransform(t_radii, p_transform);

return MCGIRectangleExpand(

MCGIRectangleIntersect(

p_shape,

MCGIRectangleUnion(

MCGIRectangleOffset(p_clip, -floor(t_transformed_offset . width), -floor(t_transformed_offset . height)),

MCGIRectangleOffset(p_clip, -ceil(t_transformed_offset . width), -ceil(t_transformed_offset . height)))),

ceil(t_transformed_radii . width), ceil(t_transformed_radii . height));

}

#endif

// The 'shape' parameter is the rectangle in user-space of the area to which the effect

// is to be applied.

//

// This shape is unrelated to the current clip, and the resulting rect of the layer which

// is to be rendered into must be big enough to ensure that any pixels rendered as a result

// of the bitmap effects have source pixels to operate on.

//

void MCGContextBeginWithEffects(MCGContextRef self, MCGRectangle p_shape, const MCGBitmapEffects& p_effects)

{

if (!MCGContextIsValid(self))

return;

MCGAffineTransform t_device_transform;

t_device_transform = MCGContextGetDeviceTransform(self);

MCGIRectangle t_device_clip;

t_device_clip = MCGRectangleComputeHull(MCGContextGetDeviceClipBounds(self));

// First transform the shape rect by the total transform to get it's rectangle in device space.

MCGIRectangle t_device_shape;

t_device_shape = MCGRectangleComputeHull(MCGRectangleApplyAffineTransform(p_shape, t_device_transform));

// This is the rectangle of pixels not related to bitmap effects which are needed.

MCGIRectangle t_layer_clip;

t_layer_clip = MCGIRectangleIntersect(t_device_clip, t_device_shape);

// This calculates the rect of pixels needed from the layer to draw the drop shadow.

// We offset the shape by the drop shadow x/y and intersect with the clip.

// We then offset it back and expand by the blur radius.

// We then intersect with the shape.

// Finally add this rectangle to the layer clip (union).

if (p_effects . has_drop_shadow)

{

MCGSize t_radii, t_offset;

t_radii = MCGSizeApplyAffineTransform(MCGSizeMake(p_effects . drop_shadow . size, p_effects . drop_shadow . size), t_device_transform);

t_offset = MCGSizeApplyAffineTransform(MCGSizeMake(p_effects . drop_shadow . x_offset, p_effects . drop_shadow . y_offset), t_device_transform);

t_layer_clip = MCGIRectangleUnion(

t_layer_clip,

MCGIRectangleIntersect(

t_device_shape,

MCGIRectangleExpand(

MCGIRectangleUnion(

MCGIRectangleOffset(

MCGIRectangleIntersect(

t_device_clip,

MCGIRectangleOffset(

t_device_shape,

floor(t_offset . width), floor(t_offset . height))),

-floor(t_offset . width), -floor(t_offset . height)),

MCGIRectangleOffset(

MCGIRectangleIntersect(

t_device_clip,

MCGIRectangleOffset(

t_device_shape,

ceil(t_offset . width), ceil(t_offset . height))),

-ceil(t_offset . width), -ceil(t_offset . height))),

ceil(t_radii . width), ceil(t_radii . height))));

}

// Next process the inner shadow.

// We intersect the shape with the clip to determine the visible pixels (as inner shadow only works internally).

// We then offset it by the inner shadow x/y (to work out what source pixels are needed)

// We then expand by the blur radius.

// We then intersect with the shape.

// Finally add this rectangle to the layer clip (union).

if (p_effects . has_inner_shadow)

{

MCGSize t_radii, t_offset;

t_radii = MCGSizeApplyAffineTransform(MCGSizeMake(p_effects . inner_shadow . size, p_effects . inner_shadow . size), t_device_transform);

t_offset = MCGSizeApplyAffineTransform(MCGSizeMake(p_effects . inner_shadow . x_offset, p_effects . inner_shadow . y_offset), t_device_transform);

// MW-2013-10-31: [[ Bug 11359 ]] Offset by -t_offset, not t_offset.

t_layer_clip = MCGIRectangleUnion(

t_layer_clip,

MCGIRectangleIntersect(

t_device_shape,

MCGIRectangleExpand(

MCGIRectangleUnion(

MCGIRectangleOffset(

MCGIRectangleIntersect(t_device_shape, t_device_clip),

-floor(t_offset . width), -floor(t_offset . height)),

MCGIRectangleOffset(

MCGIRectangleIntersect(t_device_shape, t_device_clip),

-ceil(t_offset . width), -ceil(t_offset . height))),

ceil(t_radii . width), ceil(t_radii . height))));

}

// Next process outer glow.

// We intersect the shape with the clip to determine visible pixels

// We then expand by the radii.

// We then intersect with the device shape to restrict to renderable pixels.

// Finally we add this rectangle to the layer clip (union).

if (p_effects . has_outer_glow)

{

MCGSize t_radii;

t_radii = MCGSizeApplyAffineTransform(MCGSizeMake(p_effects . outer_glow . size, p_effects . outer_glow . size), t_device_transform);

t_layer_clip = MCGIRectangleUnion(

t_layer_clip,

MCGIRectangleIntersect(

t_device_shape,

MCGIRectangleExpand(

MCGIRectangleIntersect(t_device_shape, t_device_clip),

ceil(t_radii . width), ceil(t_radii . height))));

}

// Next process inner glow.

// We intersect the shape with the clip to determine visible pixels (inner glow only works internally).

// We then expand by the radii.

// We then intersect with the shape

// Finally we add this rectangle to the layer clip (union).

if (p_effects . has_inner_glow)

{

// MW-2013-10-31: [[ Bug 11359 ]] Make sure we use the inner_glow size size field, not the outer_glow one.

MCGSize t_radii;

t_radii = MCGSizeApplyAffineTransform(MCGSizeMake(p_effects . inner_glow . size, p_effects . inner_glow . size), t_device_transform);

t_layer_clip = MCGIRectangleUnion(

t_layer_clip,

MCGIRectangleIntersect(

t_device_shape,

MCGIRectangleExpand(

MCGIRectangleIntersect(t_device_clip, t_device_shape),

ceil(t_radii . width), ceil(t_radii . height))));

}

t_layer_clip = MCGIRectangleIntersect(t_layer_clip, t_device_shape);

// IM-2014-06-24: [[ GraphicsPerformance ]] If the clip is empty then don't try to create a new layer

if ((t_layer_clip.left >= t_layer_clip.right) || (t_layer_clip.top >= t_layer_clip.bottom))

{

self -> layer -> nesting += 1;

return;

}

// Create a suitable bitmap.

SkBitmap t_new_bitmap;

t_new_bitmap . setConfig(SkBitmap::kARGB_8888_Config, t_layer_clip . right - t_layer_clip . left, t_layer_clip . bottom - t_layer_clip . top);

t_new_bitmap . setAlphaType(kPremul_SkAlphaType);

if (!t_new_bitmap . allocPixels())

{

self -> is_valid = false;

return;

}

// Clear the pixel buffer.

memset(t_new_bitmap . getPixels(), 0x00, t_new_bitmap . rowBytes() * t_new_bitmap . height());

// We now create a canvas the same size as the device clip.

SkCanvas *t_new_canvas;

t_new_canvas = new SkCanvas(t_new_bitmap);

if (t_new_canvas == nil)

{

self -> is_valid = false;

return;

}

SkAutoUnref t_canvas_au(t_new_canvas);

// Next translate the canvas by the translation factor of the matrix.

t_new_canvas -> translate(-t_layer_clip . left, -t_layer_clip . top);

// Set the matrix.

t_new_canvas -> concat(self -> layer -> canvas -> getTotalMatrix());

// Make a save point in the new canvas.

t_new_canvas -> save();

// Set the current state as the layer being pt.

self -> state -> is_layer_begin_pt = true;

// Push the current state onto the attribute stack.

MCGContextPushState(self);

self -> state -> opacity = 1.0;

self -> state -> blend_mode = kMCGBlendModeSourceOver;

// Now create the layer.

MCGContextLayerRef t_new_layer;

if (!MCGContextLayerCreate(t_new_canvas, t_new_layer))

{

self -> is_valid = false;

return;

}

t_new_layer -> parent = self -> layer;

t_new_layer -> origin_x = t_layer_clip . left;

t_new_layer -> origin_y = t_layer_clip . top;

t_new_layer -> has_effects = true;

t_new_layer -> effects = p_effects;

self -> layer = t_new_layer;

}

#if 0

class MCGContextEffectShader: public SkShader

{

public:

MCGContextEffectShader(const SkMask *mask, const SkMask *blurred_mask, SkShader *color)

{

m_mask = mask;

m_blurred_mask = blurred_mask;

m_color = color;

}

~MCGContextEffectShader(void)

{

}

virtual bool setContext(const SkBitmap& p_bitmap, const SkPaint& p_paint, const SkMatrix& p_matrix)

{

if (!SkShader::setContext(p_bitmap, p_paint, p_matrix))

return false;

if (!m_color -> setContext(p_bitmap, p_paint, p_matrix))

return false;

}

virtual void endContext(void)

{

m_color -> endContext();

SkShader::endContext();

}

virtual Factory getFactory() { return nil; }

protected:

const SkMask *m_mask;

const SkMask *m_blurred_mask;

SkShader *m_color;

};

class MCGContextEffectInnerShader: public SkShader

{

public:

MCGContextEffectInnerShader(const SkMask *mask, const SkMask *blurred_mask, SkShader *color)

: MCGContextEffectShader(mask, blurred_mask, color)

{

}

~MCGContextEffectInnerShader(void)

{

}

virtual void shadeSpan(int x, int y, SkPMColor dstC[], int count)

{

if (y < m_mask -> fBounds . top() || y >= m_mask -> fBounds . bottom() ||

x >= m_mask -> fBounds . right() || x + count < m_mask -> fBounds . left())

{

sk_memset32(dstC, 0, count);

return;

}

if (x < m_mask -> fBounds . left())

{

sk_memset32(dstC, 0, m_mask -> fBounds . left() - x);

dstC += m_mask -> fBounds . left() - x;

x = m_mask -> fBounds . left();

}

if (x + count > m_mask -> fBounds . right())

{

sk_memset32(dstC + m_mask -> fBounds . right() - (x + count), 0, x + count - m_mask -> fBounds . right());

count -= (m_mask -> fBounds . right() - (x + count));

}

// First fill the span with the shader's colors.

m_color -> shadeSpan(x, y, dstC, count);

// Now apply the mask.

uint8_t *t_mask_ptr, *t_blurred_mask_ptr;

t_mask_ptr = m_mask -> getAddr8(x, y);

t_blurred_mask_ptr = m_blurred_mask -> getAddr8(x, y);

for(int i = 0; i < count; i++)

dstC[i] = SkAlphaMulQ(dstC[i], SkAlpha255To256(SkAlphaMul(t_blurred_mask_ptr[i], SkAlpha255To256(t_mask_ptr[i]))));

}

};

class MCGContextEffectInvertedInnerShader: public SkShader

{

public:

MCGContextEffectInvertedInnerShader(const SkMask *mask, const SkMask *blurred_mask, SkShader *color)

: MCGContextEffectShader(mask, blurred_mask, color)

{

}

~MCGContextEffectInvertedInnerShader(void)

{

}

virtual void shadeSpan(int x, int y, SkPMColor dstC[], int count)

{

if (y < m_mask -> fBounds . top() || y >= m_mask -> fBounds . bottom() ||

x >= m_mask -> fBounds . right() || x + count < m_mask -> fBounds . left())

{

sk_memset32(dstC, 0, count);

return;

}

if (x < m_mask -> fBounds . left())

{

sk_memset32(dstC, 0, m_mask -> fBounds . left() - x);

dstC += m_mask -> fBounds . left() - x;

x = m_mask -> fBounds . left();

}

if (x + count > m_mask -> fBounds . right())

{

sk_memset32(dstC + m_mask -> fBounds . right() - (x + count), 0, x + count - m_mask -> fBounds . right());

count -= (m_mask -> fBounds . right() - (x + count));

}

// First fill the span with the shader's colors.

m_color -> shadeSpan(x, y, dstC, count);

// Now apply the mask.

uint8_t *t_mask_ptr, *t_blurred_mask_ptr;

t_mask_ptr = m_mask -> getAddr8(x, y);

t_blurred_mask_ptr = m_blurred_mask -> getAddr8(x, y);

for(int i = 0; i < count; i++)

dstC[i] = SkAlphaMulQ(dstC[i], SkAlpha255To256(SkAlphaMul(t_blurred_mask_ptr[i], SkAlpha255To256(t_mask_ptr[i]))));

}

};

#endif

static void MCGContextRenderEffect(MCGContextRef self, const SkMask& p_mask, MCGSize p_radii, MCGSize p_offset, MCGFloat p_spread, MCGBlurType p_attenuation, MCGColor p_color, MCGBlendMode p_blend)

{

// Get the device transform.

MCGAffineTransform t_transform;

t_transform = MCGContextGetDeviceTransform(self);

// Compute the transforms of the radii and offset.

MCGSize t_transformed_radii, t_transformed_offset;

t_transformed_radii = MCGSizeApplyAffineTransform(p_radii, t_transform);

t_transformed_offset = MCGSizeApplyAffineTransform(p_offset, t_transform);

// Now blur the mask.