{

// The string key for the property

const char *token;

// The corresponding property value

MCBitmapEffectProperty value;

// The bit-mask determining which effect types it is applicable to

uint32_t mask;

{

// If a lookup error occurs, we store it in this var so we can add it to the

// error list.

Exec_errors t_error;

t_error = EE_BITMAPEFFECT_BADKEY;

for(uint4 i = 0; i < ELEMENTS(s_bitmap_effect_properties); i++)

{

// Check to see if we've found a match.

if (MCNameIsEqualToCString(p_token, s_bitmap_effect_properties[i] . token, kMCCompareCaseless))

{

// Check to see if its applicable to this type.

if ((s_bitmap_effect_properties[i] . mask & (1 << p_type)) != 0)

{

r_prop = s_bitmap_effect_properties[i] . value;

return ES_NORMAL;

}

// The key wasn't applicable to this type.

t_error = EE_BITMAPEFFECT_BADKEYFORTYPE;

break;

}

}

// Add the error to the error list.

MCeerror -> add(t_error, 0, 0, p_token);

return ES_ERROR;

{

// Initialize ourselves to empty.

self = NULL;

{

// If we are the empty list, there is nothing to do.

if (self == NULL)

return;

// Free the effects object.

delete self;

{

// Get rid of any effects object that is present.

MCBitmapEffectsFinalize(self);

// Set ourselves to empty.

self = NULL;

{

// No effects are interior only (they have no effect at all!).

if (self == nil)

return true;

// Only interior if mask does not contain outerglow / drop-shadow.

return (self -> mask & (kMCBitmapEffectTypeDropShadowBit | kMCBitmapEffectTypeOuterGlowBit)) == 0;

{

// We will first build our new value.

MCBitmapEffects *t_new_self;

// If the source is not NULL, then we allocate a new object

if (src != NULL)

{

// Allocate, returning false if it fails.

t_new_self = new MCBitmapEffects;

if (t_new_self == NULL)

return false;

// Copy across the source - since MCBitmapEffects is just a POD type

// at the moment this is easy.

memcpy(t_new_self, src, sizeof(MCBitmapEffects));

}

else

t_new_self = NULL;

// Get rid of any effects object that we are currently attached to.

MCBitmapEffectsFinalize(self);

// Now assign our new self.

self = t_new_self;

return true;

{

// Nothing to do if we are empty

if (self == NULL)

return true;

// Now just scale the relevant portions of the effects. Note that this is

// currently not quite correct due to field size limits in the effects

// structure - thus we need to change this slightly (although for now it

// bounds the maximum size to 64, which is computationally feasible).

for(uint32_t t_type = 0; t_type <= 4; t_type += 1)

{

if ((self -> mask & (1 << t_type)) == 0)

continue;

self -> effects[t_type] . blur . size = MCU_min((signed)self -> effects[t_type] . blur . size * p_scale, 255);

if (t_type < 2)

self -> effects[t_type] . shadow . distance = MCU_min((signed)self -> effects[t_type] . shadow . distance * p_scale, 32767);

}

return true;

{

uint8_t r, g, b, a;

MCGPixelUnpack(kMCGPixelFormatBGRA, p_color, r, g, b, a);

r_color . pixel = MCGPixelPackNative(r, g, b, a);

r_color . red = r;

r_color . green = g;

r_color . blue = b;

r_color . red |= r_color . red << 8;

r_color . green |= r_color . green << 8;

r_color . blue |= r_color . blue << 8;

{

uint8_t r, g, b, a;

MCGPixelUnpackNative(p_color . pixel, r, g, b, a);

r_color = MCGPixelPack(kMCGPixelFormatBGRA, r, g, b, a);

{

// Default color is 75% black

p_effect -> layer . color = MCGPixelPackNative(0, 0, 0, 0xbf);

// Default blend mode is normal

p_effect -> layer . blend_mode = kMCBitmapEffectBlendModeNormal;

if (((1 << p_type) & kMCBitmapEffectTypeAllBlurBits) != 0)

{

// Default filter is 3-pass box filter

p_effect -> blur . filter = kMCBitmapEffectFilterThreePassBox;

// Default size is 5

p_effect -> blur . size = 5;

// Default spread is 0% as we want consistency of look between the

// filters, and box filter doesn't do spread yet.

p_effect -> blur . spread = 0x00;

if (((1 << p_type) & kMCBitmapEffectTypeAllShadowBits) != 0)

{

// Default angle is 60

p_effect -> shadow . angle = 60;

// Default distance is 5

p_effect -> shadow . distance = 5;

// Default knockout is true

p_effect -> shadow . knockout = true;

}

else if (((1 << p_type) & kMCBitmapEffectTypeAllGlowBits) != 0)

{

// Default range is 255

p_effect -> glow . range = 255;

// Default source is edge

p_effect -> glow . source = kMCBitmapEffectSourceEdge;

}

}

{

uint32_t t_size;

t_size = sizeof(uint32_t);

// Weigh the drop shadow

if ((self -> mask & kMCBitmapEffectTypeDropShadowBit) != 0)

t_size += kMCShadowEffectPickleSize;

// Weigh the outer glow

if ((self -> mask & kMCBitmapEffectTypeOuterGlowBit) != 0)

t_size += kMCGlowEffectPickleSize;

// Weigh the inner shadow

if ((self -> mask & kMCBitmapEffectTypeInnerShadowBit) != 0)

t_size += kMCShadowEffectPickleSize;

// Weigh the inner glow

if ((self -> mask & kMCBitmapEffectTypeInnerGlowBit) != 0)

t_size += kMCGlowEffectPickleSize;

// Weigh the color overlay

if ((self -> mask & kMCBitmapEffectTypeColorOverlayBit) != 0)

t_size += kMCLayerEffectPickleSize;

// Return the weight

return t_size;

{

IO_stat t_stat;

// MM-2013-12-10: [[ Bug 11568 ]] Colors are now BGRA so no longer need to convert to standard form.

t_stat = p_stream . WriteU32(self -> color);

if (t_stat == IO_NORMAL)

t_stat = p_stream . WriteU8(self -> blend_mode << 4);

return t_stat;

{

IO_stat t_stat;

// MM-2013-12-10: [[ Bug 11568 ]] Colors are now BGRA so no longer need to convert to standard form.

t_stat = p_stream . WriteU32(self -> color);

if (t_stat == IO_NORMAL)

t_stat = p_stream . WriteU32((self -> blend_mode << 28) | (self -> filter << 25) | (self -> size << 17) | (self -> spread << 9) | (self -> angle << 0));

if (t_stat == IO_NORMAL)

t_stat = p_stream . WriteU16((self -> distance << 1) | (self -> knockout << 0));

return t_stat;

{

IO_stat t_stat;

// MM-2013-12-10: [[ Bug 11568 ]] Colors are now BGRA so no longer need to convert to standard form.

t_stat = p_stream . WriteU32(self -> color);

if (t_stat == IO_NORMAL)

t_stat = p_stream . WriteU32((self -> blend_mode << 28) | (self -> filter << 25) | (self -> size << 17) | (self -> spread << 9) | (self -> range << 1) | (self -> source << 0));

return t_stat;

{

IO_stat t_stat;

t_stat = IO_NORMAL;

// Write out the size

if (t_stat == IO_NORMAL)

t_stat = p_stream . WriteU16(MCBitmapEffectsWeigh(self));

// Write out the mask

if (t_stat == IO_NORMAL)

t_stat = p_stream . WriteU16(self -> mask);

// Weigh the drop shadow

if (t_stat == IO_NORMAL && (self -> mask & kMCBitmapEffectTypeDropShadowBit) != 0)

t_stat = MCShadowEffectPickle(&self -> effects[kMCBitmapEffectTypeDropShadow] . shadow, p_stream);

// Weigh the outer glow

if (t_stat == IO_NORMAL && (self -> mask & kMCBitmapEffectTypeOuterGlowBit) != 0)

t_stat = MCGlowEffectPickle(&self -> effects[kMCBitmapEffectTypeOuterGlow] . glow, p_stream);

// Weigh the inner shadow

if (t_stat == IO_NORMAL && (self -> mask & kMCBitmapEffectTypeInnerShadowBit) != 0)

t_stat = MCShadowEffectPickle(&self -> effects[kMCBitmapEffectTypeInnerShadow] . shadow, p_stream);

// Weigh the inner glow

if (t_stat == IO_NORMAL && (self -> mask & kMCBitmapEffectTypeInnerGlowBit) != 0)

t_stat = MCGlowEffectPickle(&self -> effects[kMCBitmapEffectTypeInnerGlow] . glow, p_stream);

// Weigh the color overlay

if (t_stat == IO_NORMAL && (self -> mask & kMCBitmapEffectTypeColorOverlayBit) != 0)

t_stat = MCLayerEffectPickle(&self -> effects[kMCBitmapEffectTypeColorOverlay] . layer, p_stream);

return t_stat;

{

IO_stat t_stat;

uint32_t t_color;

t_stat = p_stream . ReadU32(t_color);

// MM-2013-12-10: [[ Bug 11568 ]] Colors are now BGRA so no longer need to convert from standard form.

self -> color = t_color;

uint8_t t_flags;

if (t_stat == IO_NORMAL)

t_stat = p_stream . ReadU8(t_flags);

if (t_stat == IO_NORMAL)

{

self -> blend_mode = (MCBitmapEffectBlendMode)(t_flags >> 4);

}

return t_stat;

{

IO_stat t_stat;

uint32_t t_color;

t_stat = p_stream . ReadU32(t_color);

// MM-2013-12-10: [[ Bug 11568 ]] Colors are now BGRA so no longer need to convert from standard form.

self -> color = t_color;

uint32_t t_data_a;

if (t_stat == IO_NORMAL)

t_stat = p_stream . ReadU32(t_data_a);

uint16_t t_data_b;

if (t_stat == IO_NORMAL)

t_stat = p_stream . ReadU16(t_data_b);

if (t_stat == IO_NORMAL)

{

self -> blend_mode = (MCBitmapEffectBlendMode)((t_data_a >> 28) & 0x0f);

self -> filter = (MCBitmapEffectFilter)((t_data_a >> 25) & 0x07);

self -> size = (t_data_a >> 17) & 0xff;

self -> spread = (t_data_a >> 9) & 0xff;

self -> angle = (t_data_a >> 0) & 0x01ff;

self -> distance = (t_data_b >> 1) & 0x7fff;

self -> knockout = (t_data_b & 0x01);

}

return t_stat;

{

IO_stat t_stat;

uint32_t t_color;

t_stat = p_stream . ReadU32(t_color);

// MM-2013-12-10: [[ Bug 11568 ]] Colors are now BGRA so no longer need to convert from standard form.

self -> color = t_color;

uint32_t t_data;

if (t_stat == IO_NORMAL)

t_stat = p_stream . ReadU32(t_data);

if (t_stat == IO_NORMAL)

{

self -> blend_mode = (MCBitmapEffectBlendMode)((t_data >> 28) & 0x0f);

self -> filter = (MCBitmapEffectFilter)((t_data >> 25) & 0x07);

self -> size = (t_data >> 17) & 0xff;

self -> spread = (t_data >> 9) & 0xff;

self -> range = (t_data >> 1) & 0xff;

self -> source = (MCBitmapEffectSource)((t_data >> 0) & 0x01);

}

return t_stat;

{

// Create a new instance

MCBitmapEffects *t_new_self;

t_new_self = new MCBitmapEffects;

if (t_new_self == NULL)

return IO_ERROR;

t_new_self -> mask = 0;

// Now read in the contents

IO_stat t_stat;

t_stat = IO_NORMAL;

// Read the size

uint16_t t_size;

if (t_stat == IO_NORMAL)

t_stat = p_stream . ReadU16(t_size);

if (t_stat == IO_NORMAL)

{

uint16_t t_mask;

t_stat = p_stream . ReadU16(t_mask);

if (t_stat == IO_NORMAL)

t_new_self -> mask = t_mask;

}

// Keep track of how much is left.

if (t_stat == IO_NORMAL)

t_size -= 4;

// Extract the drop shadow

if ((t_stat == IO_NORMAL && t_new_self -> mask & kMCBitmapEffectTypeDropShadowBit) != 0)

{

t_size -= kMCShadowEffectPickleSize;

t_stat = MCShadowEffectUnpickle(&t_new_self -> effects[kMCBitmapEffectTypeDropShadow] . shadow, p_stream);

}

// Extract the outer glow

if (t_stat == IO_NORMAL && (t_new_self -> mask & kMCBitmapEffectTypeOuterGlowBit) != 0)

{

t_size -= kMCGlowEffectPickleSize;

t_stat = MCGlowEffectUnpickle(&t_new_self -> effects[kMCBitmapEffectTypeOuterGlow] . glow, p_stream);

}

// Extract the inner shadow

if (t_stat == IO_NORMAL && (t_new_self -> mask & kMCBitmapEffectTypeInnerShadowBit) != 0)

{

t_size -= kMCShadowEffectPickleSize;

t_stat = MCShadowEffectUnpickle(&t_new_self -> effects[kMCBitmapEffectTypeInnerShadow] . shadow, p_stream);

}

// Extract the inner glow

if (t_stat == IO_NORMAL && (t_new_self -> mask & kMCBitmapEffectTypeInnerGlowBit) != 0)

{

t_size -= kMCGlowEffectPickleSize;

t_stat = MCGlowEffectUnpickle(&t_new_self -> effects[kMCBitmapEffectTypeInnerGlow] . glow, p_stream);

}

// Extract the color overlay

if (t_stat == IO_NORMAL && (t_new_self -> mask & kMCBitmapEffectTypeColorOverlayBit) != 0)

{

t_size -= kMCLayerEffectPickleSize;

t_stat = MCLayerEffectUnpickle(&t_new_self -> effects[kMCBitmapEffectTypeColorOverlay] . layer, p_stream);

}

if (t_stat == IO_NORMAL && t_size > 0)

t_stat = p_stream . Read(NULL, t_size);

// Assign the effects to the output pointer

if (t_stat == IO_NORMAL)

MCBitmapEffectsAssign(self, t_new_self);

// And finalize the temporary copy.

MCBitmapEffectsFinalize(t_new_self);

return t_stat;

{

// Compute the displacement of the shadow from the shape

int32_t t_delta_x, t_delta_y;

t_delta_x = (int32_t)floor(0.5 + self -> distance * cos(self -> angle * M_PI / 180.0));

t_delta_y = (int32_t)floor(0.5 + self -> distance * sin(self -> angle * M_PI / 180.0));

// Now inversely displace the clip and intersect with the shape to get the

// unblurred region of the shape we need to render the shadow. The expand.

return MCU_reduce_rect(MCU_intersect_rect(p_shape, MCU_offset_rect(p_clip, -t_delta_x, -t_delta_y)), -(signed)self -> size);

{

MCRectangle t_layer_clip;

t_layer_clip = MCU_intersect_rect(p_clip, p_shape);

// Drop shadows require pixels from a displaced region

if ((self -> mask & kMCBitmapEffectTypeDropShadowBit) != 0)

t_layer_clip = MCU_union_rect(t_layer_clip, MCShadowEffectComputeClip(&self -> effects[kMCBitmapEffectTypeDropShadow] . shadow, p_shape, p_clip));

// Inner shadows require pixels from a displaced region

if ((self -> mask & kMCBitmapEffectTypeInnerShadowBit) != 0)

t_layer_clip = MCU_union_rect(t_layer_clip, MCShadowEffectComputeClip(&self -> effects[kMCBitmapEffectTypeInnerShadow] . shadow, p_shape, p_clip));

// Outer glows require extra pixels for the blur

if ((self -> mask & kMCBitmapEffectTypeOuterGlowBit) != 0)

t_layer_clip = MCU_union_rect(t_layer_clip, MCGlowEffectComputeClip(&self -> effects[kMCBitmapEffectTypeOuterGlow] . glow, p_shape, p_clip));

// Inner glows require extra pixels for the blur

if ((self -> mask & kMCBitmapEffectTypeInnerGlowBit) != 0)

t_layer_clip = MCU_union_rect(t_layer_clip, MCGlowEffectComputeClip(&self -> effects[kMCBitmapEffectTypeInnerGlow] . glow, p_shape, p_clip));

r_layer_clip = MCU_intersect_rect(p_shape, t_layer_clip);

{

// Compute the displacement of the shadow from the shape

int32_t t_delta_x, t_delta_y;

t_delta_x = (int32_t)floor(0.5 + self -> distance * cos(self -> angle * M_PI / 180.0));

t_delta_y = (int32_t)floor(0.5 + self -> distance * sin(self -> angle * M_PI / 180.0));

return MCU_reduce_rect(MCU_offset_rect(p_shape, t_delta_x, t_delta_y), -(signed)self -> size);

{

// The bounds are at least as big as the shape.

MCRectangle t_bounds;

t_bounds = p_shape;

// Only drop shadows and outer glows have an effect on the exterior bounds.

if ((self -> mask & kMCBitmapEffectTypeDropShadowBit) != 0)

t_bounds = MCU_union_rect(t_bounds, MCDropShadowEffectComputeBounds(&self -> effects[kMCBitmapEffectTypeDropShadow] . shadow, p_shape));

if ((self -> mask & kMCBitmapEffectTypeOuterGlowBit) != 0)

t_bounds = MCU_union_rect(t_bounds, MCOuterGlowEffectComputeBounds(&self -> effects[kMCBitmapEffectTypeOuterGlow] . glow, p_shape));

r_bounds = t_bounds;

{

if (effect == nil)

{

r_value . stringref_value = MCValueRetain(kMCEmptyString);

r_value . type = kMCExecValueTypeStringRef;

return;

}

switch(p_prop)

{

case kMCBitmapEffectPropertyColor:

MCBitmapEffectColorToMCColor(effect->layer.color, r_value . color_value);

r_value . type = kMCExecValueTypeColor;

break;

case kMCBitmapEffectPropertyBlendMode:

MCExecFormatEnum(ctxt, kMCInterfaceBitmapEffectBlendModeTypeInfo, (intenum_t)effect->layer.blend_mode, r_value);

break;

case kMCBitmapEffectPropertyFilter:

MCExecFormatEnum(ctxt, kMCInterfaceBitmapEffectFilterTypeInfo, (intenum_t)effect->blur.filter, r_value);

break;

case kMCBitmapEffectPropertySource:

MCExecFormatEnum(ctxt, kMCInterfaceBitmapEffectSourceTypeInfo, (intenum_t)effect -> glow . source, r_value);

break;

case kMCBitmapEffectPropertyOpacity:

// MM-2013-12-10: [[ Bug 11568 ]] Store colors as BGRA instead of native since never directly rasterized.

r_value . uint_value = MCGPixelGetAlpha(kMCGPixelFormatBGRA, effect -> layer . color);

r_value . type = kMCExecValueTypeUInt;

break;

case kMCBitmapEffectPropertySize:

r_value . uint_value = effect -> blur . size;

r_value . type = kMCExecValueTypeUInt;

break;

case kMCBitmapEffectPropertySpread:

r_value . uint_value = effect -> blur . spread;

r_value . type = kMCExecValueTypeUInt;

break;

case kMCBitmapEffectPropertyDistance:

r_value . uint_value = effect -> shadow . distance;

r_value . type = kMCExecValueTypeUInt;

break;

case kMCBitmapEffectPropertyAngle:

r_value . uint_value = effect -> shadow . angle;

r_value . type = kMCExecValueTypeUInt;

break;

case kMCBitmapEffectPropertyRange:

r_value . uint_value = effect -> glow . range;

r_value . type = kMCExecValueTypeUInt;

break;

case kMCBitmapEffectPropertyKnockOut:

r_value . bool_value = effect -> shadow . knockout;

r_value . type = kMCExecValueTypeBool;

break;

default:

break;

}

{

// First map the property type

MCBitmapEffectType t_type;

t_type = (MCBitmapEffectType)(which - P_BITMAP_EFFECT_DROP_SHADOW);

// If 'p_index' is the empty name, this is a whole array op.

bool t_is_array;

t_is_array = MCNameIsEmpty(p_index);

// Now fetch the bitmap effect we are processing - note that if this is

// NULL it means it isn't set. In this case we still carry on since we

// need to report a invalid key error (if applicable).

MCBitmapEffect *t_effect;

if (self != nil && (self -> mask & (1 << t_type)) != 0)

t_effect = &self -> effects[t_type];

else

t_effect = nil;

MCBitmapEffectProperty t_prop;

if (!MCNameIsEmpty(p_index) && MCBitmapEffectLookupProperty(t_type, p_index, t_prop) != ES_NORMAL)

return false;

if (t_is_array)

{

if (t_effect == nil)

{

r_value . stringref_value = MCValueRetain(kMCEmptyString);

r_value . type = kMCExecValueTypeStringRef;

return true;

}

// Otherwise we have an array get, so first create a new value

MCAutoArrayRef v;

if (MCArrayCreateMutable(&v))

{

// Now loop through all the properties, getting the ones applicable to this type.

for(uint32_t i = 0; i < ELEMENTS(s_bitmap_effect_properties); i++)

{

if ((s_bitmap_effect_properties[i] . mask & (1 << t_type)) != 0)

{

MCExecValue t_value;

MCAutoValueRef t_valueref;

// Fetch the property, then store it into the array.

MCBitmapEffectFetchProperty(ctxt, t_effect, s_bitmap_effect_properties[i] . value, t_value);

MCExecTypeConvertAndReleaseAlways(ctxt, t_value . type, &t_value , kMCExecValueTypeValueRef, &(&t_valueref));

MCArrayStoreValue(*v, ctxt . GetCaseSensitive(), MCNAME(s_bitmap_effect_properties[i] . token), *t_valueref);

}

}

r_value . arrayref_value = MCValueRetain(*v);

r_value . type = kMCExecValueTypeArrayRef;

return true;

}

}

else

{

MCBitmapEffectFetchProperty(ctxt, t_effect, t_prop, r_value);

return true;

}

return false;

{

switch (p_prop)

{

case kMCBitmapEffectPropertyColor:

{

// MM-2013-12-10: [[ Bug 11568 ]] Store colors as BGRA instead of native since never directly rasterized.

uint4 t_new_color;

t_new_color = MCGPixelPack(kMCGPixelFormatBGRA, p_color.red >> 8, p_color.green >> 8, p_color.blue >> 8, MCGPixelGetAlpha(kMCGPixelFormatBGRA, x_effect . layer . color));

if (t_new_color != x_effect . layer . color)

{

x_effect . layer . color = t_new_color;

x_dirty = true;

}

}

break;

default:

break;

}

{

intenum_t t_value;

switch (p_prop)

{

case kMCBitmapEffectPropertyBlendMode:

{

MCExecParseEnum(ctxt, kMCInterfaceBitmapEffectBlendModeTypeInfo, p_value, t_value);

if (!ctxt . HasError())

{

MCBitmapEffectBlendMode t_new_mode;

t_new_mode = (MCBitmapEffectBlendMode)t_value;

if (t_new_mode != x_effect . layer . blend_mode)

{

x_effect . layer . blend_mode = t_new_mode;

x_dirty = true;

}

}

}

break;

case kMCBitmapEffectPropertyFilter:

{

MCExecParseEnum(ctxt, kMCInterfaceBitmapEffectFilterTypeInfo, p_value, t_value);

if (!ctxt . HasError())

{

MCBitmapEffectFilter t_new_filter;

t_new_filter = (MCBitmapEffectFilter)t_value;

if (t_new_filter != x_effect . blur . filter)

{

x_effect . blur . filter = t_new_filter;

x_dirty = true;

}

}

}

break;

case kMCBitmapEffectPropertySource:

{

MCExecParseEnum(ctxt, kMCInterfaceBitmapEffectSourceTypeInfo, p_value, t_value);

if (!ctxt . HasError())

{

MCBitmapEffectSource t_new_source;

t_new_source = (MCBitmapEffectSource)t_value;

if (t_new_source != x_effect . glow . source)

{

x_effect . glow . source = t_new_source;

x_dirty = true;

}

}

}

break;

default:

break;

}

{

switch (p_prop)

{

case kMCBitmapEffectPropertyOpacity:

{

p_uint = MCU_min(p_uint, (uint4)255);

// MM-2013-12-10: [[ Bug 11568 ]] Store colors as BGRA instead of native since never directly rasterized.

if (p_uint != MCGPixelGetAlpha(kMCGPixelFormatBGRA, x_effect . layer . color))

{

uint8_t r, g, b, a;

MCGPixelUnpack(kMCGPixelFormatBGRA, x_effect . layer . color, r, g, b, a);

x_effect . layer . color = MCGPixelPack(kMCGPixelFormatBGRA, r, g, b, p_uint);

x_dirty = true;

}

}

break;

case kMCBitmapEffectPropertySize:

{

p_uint = MCU_min(p_uint, (uint4)255);

if (p_uint != x_effect . blur . size)

{

x_effect . blur . size = p_uint;

x_dirty = true;

}

}

break;

case kMCBitmapEffectPropertySpread:

{

p_uint = MCU_min(p_uint, (uint4)255);

if (p_uint != x_effect . blur . spread)

{

x_effect . blur . spread = p_uint;

x_dirty = true;

}

}

break;

case kMCBitmapEffectPropertyDistance:

{

p_uint = MCU_min(p_uint, (uint4)32767);

if (p_uint != x_effect . shadow . distance)

{

x_effect . shadow . distance = p_uint;

x_dirty = true;

}

}

break;

case kMCBitmapEffectPropertyAngle:

{

p_uint %= 360;

if (p_uint != x_effect . shadow . angle)

{

x_effect . shadow . angle = p_uint;

x_dirty = true;

}

}

break;

// AL-2014-11-25: [[ Bug 14092 ]] Can't set glow range property

case kMCBitmapEffectPropertyRange:

{

p_uint = MCU_min(p_uint, (uint4)255);

if (p_uint != x_effect . glow . range)

{

x_effect . glow . range = p_uint;

x_dirty = true;

}

}

break;

}

{

switch (p_prop)

{

// AL-2014-11-25: [[ Bug 14092 ]] Can't set shadow knockout property

case kMCBitmapEffectPropertyKnockOut:

{

if (p_setting != x_effect . shadow . knockout)

{

x_effect . shadow . knockout = p_setting;

x_dirty = true;

}

}

break;

default:

break;

}

{

switch (p_prop)

{

case kMCBitmapEffectPropertyColor:

{

MCColor t_color;

MCExecTypeConvertAndReleaseAlways(ctxt, p_value . type, &p_value , kMCExecValueTypeColor, &t_color);

MCBitmapEffectsSetColorProperty(x_effect, p_prop, t_color, r_dirty);

}

break;

case kMCBitmapEffectPropertyBlendMode:

case kMCBitmapEffectPropertyFilter:

case kMCBitmapEffectPropertySource:

MCBitmapEffectsSetEnumProperty(ctxt, x_effect, p_prop, p_value, r_dirty);

break;

case kMCBitmapEffectPropertyOpacity:

case kMCBitmapEffectPropertySize:

case kMCBitmapEffectPropertySpread:

case kMCBitmapEffectPropertyDistance:

case kMCBitmapEffectPropertyAngle:

// AL-2014-11-25: [[ Bug 14092 ]] Can't set glow range property

case kMCBitmapEffectPropertyRange:

{

uinteger_t t_value;

MCExecTypeConvertAndReleaseAlways(ctxt, p_value . type, &p_value , kMCExecValueTypeUInt, &t_value);

MCBitmapEffectsSetUIntProperty(x_effect, p_prop, t_value, r_dirty);

}

break;

// AL-2014-11-25: [[ Bug 14092 ]] Can't set shadow knockout property

case kMCBitmapEffectPropertyKnockOut:

{

bool t_value;

MCExecTypeConvertAndReleaseAlways(ctxt, p_value . type, &p_value, kMCExecValueTypeBool, &t_value);

MCBitmapEffectsSetBooleanProperty(x_effect, p_prop, t_value, r_dirty);

}

break;

default:

break;

}

{

// First map the property type

MCBitmapEffectType t_type;

t_type = (MCBitmapEffectType)(which - P_BITMAP_EFFECT_DROP_SHADOW);

// If 'p_index' is the empty name, this is a whole array op.

bool t_is_array;

t_is_array = MCNameIsEmpty(p_index);

// AL-2014-05-21: [[ Bug 12459 ]] Ensure setting bitmap effect array to anything

// that isn't an array does the same as setting it to 'empty'.

// AL_2014-05-23: [[ Bug 12483 ]] Only do this if we are setting all the properties at once.

if (t_is_array &&

(p_value . type == kMCExecValueTypeValueRef &&

(MCValueIsEmpty(p_value . valueref_value) ||

(MCValueGetTypeCode(p_value . valueref_value) != kMCValueTypeCodeArray))))

{

if (self == nil || (self -> mask & (1 << t_type)) == 0)

{

r_dirty = false;

return true;

}

// We are set, so just unset our bit in the mask

self -> mask &= ~(1 << t_type);

// If we are now empty, then clear.

if (self -> mask == 0)

MCBitmapEffectsClear(self);

// Mark the object as dirty

r_dirty = true;

return true;

}

MCBitmapEffectProperty t_prop;

MCBitmapEffect effect;

bool t_dirty;

// Now fetch the bitmap effect we are processing - note that if this is

// NULL it means it isn't set. In this case we still carry on since we

// need to report a invalid key error (if applicable).

if (self != nil && (self -> mask & (1 << t_type)) != 0)