{

switch(p_function)

{

case GXcopy: r_mode = kMCCustomPrinterBlendSrcOver; break;

case GXblendSrc: r_mode = kMCCustomPrinterBlendSrc; break;

case GXblendDst: r_mode = kMCCustomPrinterBlendDst; break;

case GXblendSrcOver: r_mode = kMCCustomPrinterBlendSrcOver; break;

case GXblendDstOver: r_mode = kMCCustomPrinterBlendDstOver; break;

case GXblendSrcIn: r_mode = kMCCustomPrinterBlendSrcIn; break;

case GXblendDstIn: r_mode = kMCCustomPrinterBlendDstIn; break;

case GXblendSrcOut: r_mode = kMCCustomPrinterBlendSrcOut; break;

case GXblendDstOut: r_mode = kMCCustomPrinterBlendDstOut; break;

case GXblendSrcAtop: r_mode = kMCCustomPrinterBlendSrcAtop; break;

case GXblendDstAtop: r_mode = kMCCustomPrinterBlendDstAtop; break;

case GXblendXor: r_mode = kMCCustomPrinterBlendXor; break;

case GXblendPlus: r_mode = kMCCustomPrinterBlendPlus; break;

case GXblendMultiply: r_mode = kMCCustomPrinterBlendMultiply; break;

case GXblendScreen: r_mode = kMCCustomPrinterBlendScreen; break;

case GXblendOverlay: r_mode = kMCCustomPrinterBlendOverlay; break;

case GXblendDarken: r_mode = kMCCustomPrinterBlendDarken; break;

case GXblendLighten: r_mode = kMCCustomPrinterBlendLighten; break;

case GXblendDodge: r_mode = kMCCustomPrinterBlendDodge; break;

case GXblendBurn: r_mode = kMCCustomPrinterBlendBurn; break;

case GXblendHardLight: r_mode = kMCCustomPrinterBlendHardLight; break;

case GXblendSoftLight: r_mode = kMCCustomPrinterBlendSoftLight; break;

case GXblendDifference: r_mode = kMCCustomPrinterBlendDifference; break;

case GXblendExclusion: r_mode = kMCCustomPrinterBlendExclusion; break;

default:

return false;

}

return true;

{

switch(p_kind)

{

case kMCGradientKindLinear: r_type = kMCCustomPrinterGradientLinear; break;

case kMCGradientKindRadial: r_type = kMCCustomPrinterGradientRadial; break;

case kMCGradientKindConical: r_type = kMCCustomPrinterGradientConical; break;

case kMCGradientKindDiamond: r_type = kMCCustomPrinterGradientDiamond; break;

case kMCGradientKindSpiral: r_type = kMCCustomPrinterGradientSpiral; break;

case kMCGradientKindXY: r_type = kMCCustomPrinterGradientXY; break;

case kMCGradientKindSqrtXY: r_type = kMCCustomPrinterGradientSqrtXY; break;

default:

return false;

}

return true;

{

MCCustomPrinterTransform t_transform;

t_transform.scale_x = p_transform.a;

t_transform.skew_x = p_transform.c;

t_transform.translate_x = p_transform.tx;

t_transform.skew_y = p_transform.b;

t_transform.scale_y = p_transform.d;

t_transform.translate_y = p_transform.ty;

return t_transform;

{

switch (p_format)

{

case kMCGRasterFormat_ARGB:

return kMCCustomPrinterImageRawARGB;

case kMCGRasterFormat_xRGB:

return kMCCustomPrinterImageRawXRGB;

case kMCGRasterFormat_A:

case kMCGRasterFormat_U_ARGB:

// Unsupported

MCAssert(false);

return kMCCustomPrinterImageNone;

}

{

MCCustomMetaContext(const MCRectangle& page);

~MCCustomMetaContext(void);

bool render(MCCustomPrintingDevice *p_device, const MCPrinterRectangle& p_src_rect, const MCPrinterRectangle& p_dst_rect, const MCPrinterRectangle& p_page_rect);

bool candomark(MCMark *mark);

void domark(MCMark *mark);

bool begincomposite(const MCRectangle &region, MCGContextRef &r_context);

MCContext *begincomposite(const MCRectangle& region);

void endcomposite(MCRegionRef clip_region);

void dopathmark(MCMark *mark, MCPath *path);

void dorawpathmark(MCMark *mark, uint1 *commands, uint32_t command_count, int4 *ordinates, uint32_t ordinate_count, bool p_evenodd);

void dotextmark(MCMark *mark);

void doimagemark(MCMark *mark);

void dolinkmark(MCMark *mark);

void transform_point(const MCPoint& in_point, MCCustomPrinterPoint& r_out_point);

void transform_rect(const MCRectangle& in_rect, MCCustomPrinterRectangle& r_out_rect);

void compute_clip(const MCRectangle& clip_rect, MCCustomPrinterRectangle& r_out_rect);

// The device we are targetting (only valid during the 'render' method).

MCCustomPrintingDevice *m_device;

// These are the transform factors to map the src to dst rect

double m_scale_x, m_scale_y;

double m_translate_x, m_translate_y;

// This is the rectangle that defines the maximum area in device space that

// can be used.

MCPrinterRectangle m_page_rect;

// If this is true, an error has occured during execute

bool m_execute_error;

// The untransformed rect and scale of current composite region

MCRectangle m_composite_rect;

uint32_t m_composite_scale;

// The compositing graphics context used to render into

MCGContextRef m_composite_context;

: MCMetaContext(p_page)

{

m_composite_context = nil;

{

m_execute_error = false;

m_device = p_device;

m_scale_x = (p_dst_rect . right - p_dst_rect . left) / (p_src_rect . right - p_src_rect . left);

m_scale_y = (p_dst_rect . bottom - p_dst_rect . top) / (p_src_rect . bottom - p_src_rect . top);

m_translate_x = -p_src_rect . left * m_scale_x + p_dst_rect . left;

m_translate_y = -p_src_rect . top * m_scale_y + p_dst_rect . top;

m_page_rect = p_page_rect;

// Run the display list

execute();

return !m_execute_error;

{

// If an error has occured during this execution, just return true to minimize

// unnecessary rasterization (this is to make up for a lack of error handling

// during the super-classes execution process).

if (m_execute_error)

return true;

// This method is called for every mark to see if it needs rasterization.

switch(p_mark -> type)

{

case MARK_TYPE_LINE:

case MARK_TYPE_POLYGON:

case MARK_TYPE_TEXT:

case MARK_TYPE_RECTANGLE:

case MARK_TYPE_ROUND_RECTANGLE:

case MARK_TYPE_ARC:

case MARK_TYPE_PATH:

{

MCCustomPrinterPaint t_paint;

// Check to see if its a gradient

if (p_mark -> fill -> gradient != nil)

{

if (!MCCustomPrinterGradientFromMCGradient((MCGradientFillKind)p_mark -> fill -> gradient -> kind, t_paint . gradient . type))

return false;

t_paint . type = kMCCustomPrinterPaintGradient;

return m_device -> CanRenderPaint(t_paint);

}

// If its a solid color we are done

if (p_mark -> fill -> style == FillSolid)

return true;

// Check to see if its a pattern

if (p_mark -> fill -> style == FillTiled)

{

t_paint . type = kMCCustomPrinterPaintPattern;

t_paint . pattern . image . type = kMCCustomPrinterImageRawARGB;

return m_device -> CanRenderPaint(t_paint);

}

// Otherwise it is FillStippled or FillOpaqueStippled - neither of which

// we support for this kind of printing (yet?)

return true;

}

break;

case MARK_TYPE_IMAGE:

{

// Devices have to support unmasked images (otherwise we couldn't

// rasterize!).

bool t_mask, t_alpha;

t_mask = !MCGImageIsOpaque(p_mark->image.descriptor.image);

t_alpha = t_mask && MCGImageHasPartialTransparency(p_mark->image.descriptor.image);

if (!t_mask)

return true;

// Now check to see if the appropriate type of masked (raw) image

// is supported.

MCCustomPrinterImage t_image;

if (t_alpha)

t_image . type = kMCCustomPrinterImageRawARGB;

else

t_image . type = kMCCustomPrinterImageRawMRGB;

return m_device -> CanRenderImage(t_image);

}

break;

case MARK_TYPE_METAFILE:

case MARK_TYPE_EPS:

case MARK_TYPE_THEME:

// These all have to be rasterized!

return false;

case MARK_TYPE_GROUP:

{

// If the group has effects we can't do it (yet!)

if (p_mark -> group . effects != nil)

return false;

// If the blend mode isn't a custom printer supported one, we can't

// do it.

MCCustomPrinterBlendMode t_blend_mode;

if (!MCCustomPrinterBlendModeFromInk(p_mark -> group . function, t_blend_mode))

return false;

// Otherwise fill in the custom group struct and ask our device

MCCustomPrinterGroup t_group;

t_group . blend_mode = t_blend_mode;

t_group . opacity = p_mark -> group . opacity / 255.0;

return m_device -> CanRenderGroup(t_group);

}

break;

case MARK_TYPE_LINK:

// We can always render links natively - even if this is a no-op.

return true;

}

// Unknown mark so return false.

return false;

{

// If an error has occured, we do nothing.

if (m_execute_error)

return;

switch(p_mark -> type)

{

case MARK_TYPE_LINE:

{

MCPath *t_path;

t_path = MCPath::create_line(p_mark -> line . start . x, p_mark -> line . start . y, p_mark -> line . end . x, p_mark -> line . end . y, true);

if (t_path != nil)

{

dopathmark(p_mark, t_path);

t_path -> release();

}

else

m_execute_error = true;

}

break;

case MARK_TYPE_POLYGON:

{

MCPath *t_path;

if (p_mark -> polygon . closed)

t_path = MCPath::create_polygon(p_mark -> polygon . vertices, p_mark -> polygon . count, true);

else

t_path = MCPath::create_polyline(p_mark -> polygon . vertices, p_mark -> polygon . count, true);

if (t_path != nil)

{

dopathmark(p_mark, t_path);

t_path -> release();

}

else

m_execute_error = true;

}

break;

case MARK_TYPE_TEXT:

dotextmark(p_mark);

break;

case MARK_TYPE_RECTANGLE:

{

// MM-2014-04-23: [[ Bug 11884 ]] Inset the bounds. Since MCPath only accepts ints, if the inset value is uneven,

// round up to the nearest even value, keeping behaviour as close to that of the graphics context as possible.

// SN-2014-10-17: [[ Bug 13351 ]] Only round up existing inset

if (p_mark -> rectangle . inset && !(p_mark -> rectangle . inset % 2))

p_mark -> rectangle . inset ++;

// SN-2014-10-17: [[ Bug 13351 ]] Be careful not to underflow the bounds

p_mark -> rectangle . bounds = MCRectangleMake(p_mark -> rectangle . bounds . x + p_mark -> rectangle . inset / 2,

p_mark -> rectangle . bounds . y + p_mark -> rectangle . inset / 2,

MCMin(p_mark -> rectangle . bounds . width, p_mark -> rectangle . bounds . width - p_mark -> rectangle . inset),

MCMin(p_mark -> rectangle . bounds . height, p_mark -> rectangle . bounds . height - p_mark -> rectangle . inset));

MCPath *t_path;

if (p_mark -> stroke != nil && p_mark -> rectangle . bounds . height == 1)

t_path = MCPath::create_line(p_mark -> rectangle . bounds . x, p_mark -> rectangle . bounds . y, p_mark -> rectangle . bounds . x + p_mark -> rectangle . bounds . width - 1, p_mark -> rectangle . bounds . y, true);

else if (p_mark -> stroke != nil && p_mark -> rectangle . bounds . width == 1)

t_path = MCPath::create_line(p_mark -> rectangle . bounds . x, p_mark -> rectangle . bounds . y, p_mark -> rectangle . bounds . x, p_mark -> rectangle . bounds . y + p_mark -> rectangle . bounds . height - 1, true);

else

t_path = MCPath::create_rectangle(p_mark -> rectangle . bounds, p_mark -> stroke != nil);

if (t_path != nil)

{

dopathmark(p_mark, t_path);

t_path -> release();

}

else

m_execute_error = true;

}

break;

case MARK_TYPE_ROUND_RECTANGLE:

{

// MM-2014-04-23: [[ Bug 11884 ]] Inset the bounds. Since MCPath only accepts ints, if the inset value is uneven,

// round up to the nearest even value, keeping behaviour as close to that of the graphics context as possible.

// SN-2014-10-17: [[ Bug 13351 ]] Only round up existing inset

if (!(p_mark -> round_rectangle . inset % 2))

p_mark -> round_rectangle . inset ++;

// SN-2014-10-17: [[ Bug 13351 ]] Be careful not to underflow the bounds

p_mark -> round_rectangle . bounds = MCRectangleMake(p_mark -> round_rectangle . bounds . x + p_mark -> round_rectangle . inset / 2,

p_mark -> round_rectangle . bounds . y + p_mark -> round_rectangle . inset / 2,

MCMin(p_mark -> round_rectangle . bounds . width, p_mark -> round_rectangle . bounds . width - p_mark -> round_rectangle . inset),

MCMin(p_mark -> round_rectangle . bounds . height, p_mark -> round_rectangle . bounds . height - p_mark -> round_rectangle . inset));

MCPath *t_path;

t_path = MCPath::create_rounded_rectangle(p_mark -> round_rectangle . bounds, p_mark -> round_rectangle . radius / 2, p_mark -> stroke != nil);

if (t_path != nil)

{

dopathmark(p_mark, t_path);

t_path -> release();

}

else

m_execute_error = true;

}

break;

case MARK_TYPE_ARC:

{

// MM-2014-04-23: [[ Bug 11884 ]] Inset the bounds. Since MCPath only accepts ints, if the inset value is uneven,

// round up to the nearest even value, keeping behaviour as close to that of the graphics context as possible.

// SN-2014-10-17: [[ Bug 13351 ]] Only round up existing inset

if (!(p_mark -> arc . inset % 2))

p_mark -> arc . inset ++;

// SN-2014-10-17: [[ Bug 13351 ]] Be careful not to underflow the bounds

p_mark -> arc . bounds = MCRectangleMake(p_mark -> arc . bounds . x + p_mark -> arc . inset / 2,

p_mark -> arc . bounds . y + p_mark -> arc . inset / 2,

MCMin(p_mark -> arc . bounds . width, p_mark -> arc . bounds . width - p_mark -> arc . inset),

MCMin(p_mark -> arc . bounds . height, p_mark -> arc . bounds . height - p_mark -> arc . inset));

MCPath *t_path;

if (p_mark -> arc . complete)

t_path = MCPath::create_segment(p_mark -> arc . bounds, p_mark -> arc . start, p_mark -> arc . angle, p_mark -> stroke != nil);

else

t_path = MCPath::create_arc(p_mark -> arc . bounds, p_mark -> arc . start, p_mark -> arc . angle, p_mark -> stroke != nil);

if (t_path != nil)

{

dopathmark(p_mark, t_path);

t_path -> release();

}

else

m_execute_error = true;

}

break;

case MARK_TYPE_PATH:

dorawpathmark(p_mark, p_mark -> path . commands, p_mark -> path . command_count, p_mark -> path . ordinates, p_mark -> path . ordinate_count, p_mark -> path . evenodd);

break;

case MARK_TYPE_IMAGE:

doimagemark(p_mark);

break;

case MARK_TYPE_GROUP:

{

// Work out the custom group properties

MCCustomPrinterGroup t_group;

MCCustomPrinterBlendModeFromInk(p_mark -> group . function, t_group . blend_mode);

t_group . opacity = p_mark -> group . opacity / 255.0;

compute_clip(p_mark -> clip, t_group . region);

// If the opacity if not 1, or the blend mode is not srcOver then we

// generate a group. Otherwise, there's no need.

if (t_group . opacity != 1.0 || t_group . blend_mode != kMCCustomPrinterBlendSrcOver)

{

if (!m_execute_error &&

!m_device -> BeginGroup(t_group))

m_execute_error = true;

if (!m_execute_error)

executegroup(p_mark);

if (!m_execute_error &&

!m_device -> EndGroup())

m_execute_error = true;

}

else

executegroup(p_mark);

}

break;

case MARK_TYPE_LINK:

dolinkmark(p_mark);

break;

default:

break;

}

{

// See if we can render the image using the original text

MCCustomPrinterImageType t_image_type;

t_image_type = kMCCustomPrinterImageNone;

if (p_mark -> image . descriptor . data_type != kMCImageDataNone)

{

switch(p_mark -> image . descriptor . data_type)

{

case kMCImageDataGIF: t_image_type = kMCCustomPrinterImageGIF; break;

case kMCImageDataPNG: t_image_type = kMCCustomPrinterImagePNG; break;

case kMCImageDataJPEG: t_image_type = kMCCustomPrinterImageJPEG; break;

default: assert(false);

}

MCCustomPrinterImage t_image;

t_image . type = t_image_type;

if (!m_device -> CanRenderImage(t_image))

t_image_type = kMCCustomPrinterImageNone;

}

uint2 t_img_width, t_img_height;

MCGRaster t_raster;

if (!m_execute_error)

{

if (!MCGImageGetRaster(p_mark->image.descriptor.image, t_raster))

m_execute_error = true;

}

if (!m_execute_error)

{

t_img_width = t_raster.width;

t_img_height = t_raster.height;

// Fill in the printer image info

MCCustomPrinterImage t_image;

if (t_image_type == kMCCustomPrinterImageNone)

{

bool t_mask, t_alpha;

t_mask = !MCGImageIsOpaque(p_mark->image.descriptor.image);

t_alpha = t_mask && MCGImageHasPartialTransparency(p_mark->image.descriptor.image);

// IM-2014-06-26: [[ Bug 12699 ]] Set image type appropriately.

t_image . type = t_alpha ? kMCCustomPrinterImageRawARGB : (t_mask ? kMCCustomPrinterImageRawMRGB : kMCCustomPrinterImageRawXRGB);

t_image . id = (uint32_t)(intptr_t)p_mark->image.descriptor.image;

t_image . data = t_raster.pixels;

t_image . data_size = t_raster.stride * t_img_height;

}

else

{

t_image . type = t_image_type;

t_image . id = (uint32_t)(intptr_t)p_mark -> image . descriptor . data_bits;

t_image . data = p_mark -> image . descriptor . data_bits;

t_image . data_size = p_mark -> image . descriptor . data_size;

}

t_image . width = t_img_width;

t_image . height = t_img_height;

// Compute the transform that is needed - this transform goes from image

// space to page space.

// IM-2014-06-26: [[ Bug 12699 ]] Rework to ensure transforms are applied in the correct order - page transform -> image offset -> image transform

MCGAffineTransform t_transform;

t_transform = MCGAffineTransformMake(m_scale_x, 0, 0, m_scale_y, m_translate_x, m_translate_y);

t_transform = MCGAffineTransformConcat(t_transform, MCGAffineTransformMakeTranslation(p_mark -> image . dx - p_mark -> image . sx, p_mark -> image . dy - p_mark -> image . sy));

if (p_mark -> image . descriptor . has_transform)

t_transform = MCGAffineTransformConcat(t_transform, p_mark -> image . descriptor . transform);

// Compute the clip that is needed - the mark alreay has the appropriate clip set.

MCCustomPrinterRectangle t_clip;

compute_clip(p_mark -> clip, t_clip);

// Render the primitive

if (!m_device -> DrawImage(t_image, MCCustomPrinterTransformFromMCGAffineTransform(t_transform), t_clip))

m_execute_error = true;

}

{

MCCustomPrinterRectangle t_region;

compute_clip(p_mark -> link . region, t_region);

if (!m_device -> MakeLink(t_region, p_mark -> link . text, kMCCustomPrinterLinkUnspecified))

m_execute_error = true;

{

bool t_success = true;

MCGContextRef t_gcontext = nil;

// TODO: Make the rasterization scale depend in some way on current scaling,

// after all there's no point in making a large rasterized bitmap if it ends

// up being printed really really small!

uint4 t_scale;

t_scale = SCALE;

uint32_t t_width = p_mark_clip.width * t_scale;

uint32_t t_height = p_mark_clip.height * t_scale;

if (t_success)

t_success = MCGContextCreate(t_width, t_height, true, t_gcontext);

MCContext *t_context = nil;

if (t_success)

{

MCGContextScaleCTM(t_gcontext, t_scale, t_scale);

MCGContextTranslateCTM(t_gcontext, -(MCGFloat)p_mark_clip . x, -(MCGFloat)p_mark_clip . y);

m_composite_context = t_gcontext;

m_composite_rect = p_mark_clip;

m_composite_scale = t_scale;

r_context = m_composite_context;

}

m_execute_error = !t_success;

return t_success;

{

uint4 *t_pixel_ptr;

uint4 t_pixel_stride;

uint1 *t_mask_ptr;

uint4 t_mask_stride;

t_pixel_ptr = (uint4 *)p_pixels;

t_pixel_stride = p_pixel_stride >> 2;

t_mask_ptr = (uint1 *)p_mask;

t_mask_stride = p_mask_stride;

for(uint4 y = p_height; y > 0; --y, t_pixel_ptr += t_pixel_stride, t_mask_ptr += t_mask_stride)

{

uint4 t_byte, t_bit;

uint1 *t_bytes;

t_bytes = t_mask_ptr;

t_bit = 0x80 >> p_offset;

t_byte = *t_bytes++;

for(uint4 x = 0; x < p_width; ++x)

{

t_pixel_ptr[x] = t_pixel_ptr[x] & 0xFFFFFF;

if ((t_byte & t_bit) != 0)

t_pixel_ptr[x] |= 0xFF000000;

t_bit >>= 1;

if (!t_bit && x < p_width - 1)

t_bit = 0x80, t_byte = *t_bytes++;

}

}

{

bool t_success = true;

MCGImageRef t_image;

t_image = nil;

t_success = nil != m_composite_context;

if (t_success)

t_success = MCGContextCopyImage(m_composite_context, t_image);

MCGContextRelease(m_composite_context);

m_composite_context = nil;

if (t_success)

{

MCGRaster t_raster;

MCGImageGetRaster(t_image, t_raster);

/* OVERHAUL - REVISIT: Disabling the mask stuff for now, just treat the composite image as ARGB */

// Make sure the region is in logical coords.

//MCRegionOffset(p_clip_region, -(signed)m_composite_rect . x * m_composite_scale, -(signed)m_composite_rect . y * m_composite_scale);

// We now need to merge the region into the surface as a 1-bit mask... So first

// get the region as such a mask

//MCBitmap *t_mask;

//if (MCRegionCalculateMask(p_clip_region, t_image -> width, t_image -> height, t_mask))

//{

// // And then merge in the mask - note we preserve the pixel data of the pixels

// // behind the mask... This is to eliminate rendering artifacts when the image

// // is resampled for display... Hmm - although the artifacts may be a cairo

// // problem - doing this doesn't seem to solve the issue!

// surface_merge_with_mask_preserve(t_image -> data, t_image -> bytes_per_line, t_mask -> data, t_mask -> bytes_per_line, 0, t_image -> width, t_image -> height);

// Now we have a masked image, issue an appropriate image rendering call to the

// device

MCCustomPrinterImage t_img_data;

t_img_data . type = kMCCustomPrinterImageRawARGB;

t_img_data . id = 0;

t_img_data . width = t_raster . width;

t_img_data . height = t_raster . height;

t_img_data . data = t_raster . pixels;

t_img_data . data_size = t_raster . stride * t_raster . height;

MCCustomPrinterTransform t_img_transform;

t_img_transform . scale_x = m_scale_x / m_composite_scale;

t_img_transform . scale_y = m_scale_y / m_composite_scale;

t_img_transform . skew_x = 0.0;

t_img_transform . skew_y = 0.0;

t_img_transform . translate_x = m_scale_x * m_composite_rect . x + m_translate_x;

t_img_transform . translate_y = m_scale_y * m_composite_rect . y + m_translate_y;

MCCustomPrinterRectangle t_img_clip;

compute_clip(m_composite_rect, t_img_clip);

t_success = m_device -> DrawImage(t_img_data, t_img_transform, t_img_clip);

// Destroy our mask image

// MCscreen -> destroyimage(t_mask);

//}

//else

// m_execute_error = true;

}

m_execute_error = !t_success;

// Delete the region

MCRegionDestroy(p_clip_region);

{

uint32_t t_command_count, t_ordinate_count;

p_path -> get_lengths(t_command_count, t_ordinate_count);

dorawpathmark(p_mark, p_path -> get_commands(), t_command_count, p_path -> get_ordinates(), t_ordinate_count, false);

{

MCCustomPrinterPathCommand *t_out_commands;

t_out_commands = new MCCustomPrinterPathCommand[p_command_count];

MCCustomPrinterPoint *t_out_coords;

t_out_coords = new MCCustomPrinterPoint[p_ordinate_count];

if (t_out_commands != nil && t_out_coords != nil)

{

for(uint32_t i = 0, j = 0; i < p_command_count; i++)

switch(p_commands[i])

{

case PATH_COMMAND_END:

t_out_commands[i] = kMCCustomPrinterPathEnd;

break;

case PATH_COMMAND_MOVE_TO:

t_out_commands[i] = kMCCustomPrinterPathMoveTo;

t_out_coords[j] . x = p_ordinates[j * 2] / 256.0;

t_out_coords[j] . y = p_ordinates[j * 2 + 1] / 256.0;

j++;

break;

case PATH_COMMAND_LINE_TO:

t_out_commands[i] = kMCCustomPrinterPathLineTo;

t_out_coords[j] . x = p_ordinates[j * 2] / 256.0;

t_out_coords[j] . y = p_ordinates[j * 2 + 1] / 256.0;

j++;

break;

case PATH_COMMAND_CUBIC_TO:

t_out_commands[i] = kMCCustomPrinterPathCubicTo;

t_out_coords[j] . x = p_ordinates[j * 2] / 256.0;

t_out_coords[j] . y = p_ordinates[j * 2 + 1] / 256.0;

j++;

t_out_coords[j] . x = p_ordinates[j * 2] / 256.0;

t_out_coords[j] . y = p_ordinates[j * 2 + 1] / 256.0;

j++;

t_out_coords[j] . x = p_ordinates[j * 2] / 256.0;

t_out_coords[j] . y = p_ordinates[j * 2 + 1] / 256.0;

j++;

break;

case PATH_COMMAND_QUADRATIC_TO:

t_out_commands[i] = kMCCustomPrinterPathQuadraticTo;

t_out_coords[j] . x = p_ordinates[j * 2] / 256.0;

t_out_coords[j] . y = p_ordinates[j * 2 + 1] / 256.0;

j++;

t_out_coords[j] . x = p_ordinates[j * 2] / 256.0;

t_out_coords[j] . y = p_ordinates[j * 2 + 1] / 256.0;

j++;

break;

case PATH_COMMAND_CLOSE:

t_out_commands[i] = kMCCustomPrinterPathClose;

break;

default:

break;

}

// First construct the printer path.

MCCustomPrinterPath t_path;

t_path . commands = t_out_commands;

t_path . coords = t_out_coords;

// Now construct the printer paint.

MCCustomPrinterPaint t_paint;

t_paint . type = kMCCustomPrinterPaintNone;

// This is a temporary array containing the gradient stops (if any).

MCCustomPrinterGradientStop *t_paint_stops;

t_paint_stops = nil;

// Note we have to check the fill in this order since 'gradient' is not

// a fill style and is indicated by the gradient field not being nil.

if (p_mark -> fill -> gradient != nil)

{

t_paint . type = kMCCustomPrinterPaintGradient;

t_paint . gradient . mirror = p_mark -> fill -> gradient -> mirror != 0;

t_paint . gradient . wrap = p_mark -> fill -> gradient -> wrap != 0;

t_paint . gradient . repeat = p_mark -> fill -> gradient -> repeat;

MCCustomPrinterGradientFromMCGradient((MCGradientFillKind)p_mark->fill->gradient->kind, t_paint.gradient.type);

// compute the affine transform of the gradient from the origin/primary/secondary points.

t_paint . gradient . transform . scale_x = p_mark->fill->gradient->primary.x - p_mark->fill->gradient->origin.x;

t_paint . gradient . transform . scale_y = p_mark->fill->gradient->secondary.y - p_mark->fill->gradient->origin.y;

t_paint . gradient . transform . skew_x = p_mark->fill->gradient->secondary.x - p_mark->fill->gradient->origin.x;

t_paint . gradient . transform . skew_y = p_mark->fill->gradient->primary.y - p_mark->fill->gradient->origin.y;

t_paint . gradient . transform . translate_x = p_mark->fill->gradient->origin.x;

t_paint . gradient . transform . translate_y = p_mark->fill->gradient->origin.y;

// Map the paint stops appropriately

t_paint_stops = new MCCustomPrinterGradientStop[p_mark -> fill -> gradient -> ramp_length];

if (t_paint_stops != nil)

{

for(uint32_t i = 0; i < p_mark -> fill -> gradient -> ramp_length; i++)

{

t_paint_stops[i] . color . red = ((p_mark -> fill -> gradient -> ramp[i] . color >> 16) & 0xff) / 255.0;

t_paint_stops[i] . color . green = ((p_mark -> fill -> gradient -> ramp[i] . color >> 8) & 0xff) / 255.0;

t_paint_stops[i] . color . blue = (p_mark -> fill -> gradient -> ramp[i] . color & 0xff) / 255.0;

t_paint_stops[i] . alpha = (p_mark -> fill -> gradient -> ramp[i] . color >> 24) / 255.0;

t_paint_stops[i] . offset = p_mark -> fill -> gradient -> ramp[i] . offset / 65535.0;

}

t_paint . gradient . stops = t_paint_stops;

t_paint . gradient . stop_count = p_mark -> fill -> gradient -> ramp_length;

}

else

m_execute_error = true;

}

else if (p_mark -> fill -> style == FillSolid)

{

t_paint . type = kMCCustomPrinterPaintSolid;

t_paint . solid . red = p_mark -> fill -> colour . red / 65535.0;

t_paint . solid . green = p_mark -> fill -> colour . green / 65535.0;

t_paint . solid . blue = p_mark -> fill -> colour . blue / 65535.0;

}

else if (p_mark -> fill -> style == FillTiled)

{

// Fetch the size of the tile, and its data.

MCGImageRef t_image;

t_image = nil;

MCGAffineTransform t_transform;

// IM-2014-05-13: [[ HiResPatterns ]] Update pattern access to use lock function

if (MCPatternLockForContextTransform(p_mark->fill->pattern, MCGAffineTransformMakeIdentity(), t_image, t_transform))

{

MCGRaster t_tile_raster;

/* UNCHECKED */ MCGImageGetRaster(t_image, t_tile_raster);

t_transform = MCGAffineTransformTranslate(t_transform, p_mark->fill->origin.x, p_mark->fill->origin.y);

// Construct the paint pattern.

t_paint . type = kMCCustomPrinterPaintPattern;

t_paint . pattern . image . type = MCCustomPrinterImageTypeFromMCGRasterFormat(t_tile_raster . format);

t_paint . pattern . image . id = (uint32_t)(intptr_t)p_mark -> fill -> pattern;

t_paint . pattern . image . width = t_tile_raster . width;

t_paint . pattern . image . height = t_tile_raster . height;

t_paint . pattern . image . data = t_tile_raster . pixels;

t_paint . pattern . image . data_size = t_tile_raster . stride * t_tile_raster . height;

t_paint . pattern . transform = MCCustomPrinterTransformFromMCGAffineTransform(t_transform);

MCPatternUnlock(p_mark->fill->pattern, t_image);

}

else

m_execute_error = true;

}

if (!m_execute_error)

{

// Compute the transform for the path. The path must be transformed by

// the printing device because it needs to happen *after* a stroke has

// been applied.

MCCustomPrinterTransform t_transform;

t_transform . scale_x = m_scale_x;

t_transform . scale_y = m_scale_y;

t_transform . skew_x = 0.0;

t_transform . skew_y = 0.0;

t_transform . translate_x = m_translate_x;

t_transform . translate_y = m_translate_y;

// Compute the clip for the path - the clip is in page-space, so we

// transform here.

MCCustomPrinterRectangle t_clip;

compute_clip(p_mark -> clip, t_clip);

if (p_mark -> stroke == nil)

{

if (!m_device -> FillPath(t_path, p_evenodd ? kMCCustomPrinterFillEvenOdd : kMCCustomPrinterFillNonZero, t_paint, t_transform, t_clip))

m_execute_error = true;

}

else

{

MCCustomPrinterStroke t_stroke;

// MW-2010-02-01: [[ Bug 8564 ]] If the width of the stroke is zero width, then the stroke

// parameters are: thickness == 1, cap == butt, join == miter.

if (p_mark -> stroke -> width != 0)

{

t_stroke . thickness = p_mark -> stroke -> width;

t_stroke . cap_style = p_mark -> stroke -> cap == CapButt ? kMCCustomPrinterCapButt :

(p_mark -> stroke -> cap == CapRound ? kMCCustomPrinterCapRound :

kMCCustomPrinterCapSquare);

t_stroke . join_style = p_mark -> stroke -> join == JoinBevel ? kMCCustomPrinterJoinBevel :

(p_mark -> stroke -> join == JoinRound ? kMCCustomPrinterJoinRound :

kMCCustomPrinterJoinMiter);

t_stroke . miter_limit = p_mark -> stroke -> miter_limit;

}

else

{

t_stroke . thickness = 1.0;

t_stroke . cap_style = kMCCustomPrinterCapButt;

t_stroke . join_style = kMCCustomPrinterJoinMiter;

t_stroke . miter_limit = 10;

}

if (p_mark -> stroke -> dash . length != 0)

{

t_stroke . dash_count = p_mark -> stroke -> dash . length;

t_stroke . dash_offset = p_mark -> stroke -> dash . offset;

t_stroke . dashes = new double[p_mark -> stroke -> dash . length];

if (t_stroke . dashes != nil)

{

for(uint32_t i = 0; i < p_mark -> stroke -> dash . length; i++)

t_stroke . dashes[i] = p_mark -> stroke -> dash . data[i];

}

else

m_execute_error = true;

}

else

{

t_stroke . dashes = nil;

t_stroke . dash_count = 0;

t_stroke . dash_offset = 0.0;

}

if (!m_execute_error)

if (!m_device -> StrokePath(t_path, t_stroke, t_paint, t_transform, t_clip))

m_execute_error = true;

delete[] t_stroke . dashes;

}

}

if (t_paint_stops != nil)

delete[] t_paint_stops;

}

else

m_execute_error = true;

delete[] t_out_coords;

delete[] t_out_commands;

{

MCCustomPrintingDevice *device;

MCCustomPrinterPaint paint;

MCCustomPrinterTransform transform;

MCCustomPrinterRectangle clip;

double font_size;

{

dotextmark_callback_state *context;

context = (dotextmark_callback_state *)p_context;

// Note we can use 'setstaticbytes' here because the execpoint is immediately

// modified.

MCExecPoint ep(nil, nil, nil);

ep . setstaticbytes((const char *)p_span -> chars, p_span -> char_count * 2);

ep . utf16toutf8();

// Get the UTF-8 string pointer and length

const uint8_t *t_bytes;

uint32_t t_byte_count;

t_bytes = (const uint8_t *)ep . getcstring();

t_byte_count = ep . getsvalue() . getlength();

// Allocate a cluster index for every UTF-8 byte

uint32_t *t_clusters;

t_clusters = nil;

if (!MCMemoryNewArray(t_byte_count, t_clusters))

return false;

// Now loop through and build up the cluster array. Notice we keep track of

// UTF-16 codepoint index by taking note of leading UTF-8 bytes.

uint32_t t_char_index, t_next_char_index;

t_char_index = t_next_char_index = 0;

for(uint32_t i = 0; i < t_byte_count; i++)

{

if ((t_bytes[i] & 0x80) == 0)

{

// This is a single byte char - so it comes from a single UTF-16 code point

t_char_index = t_next_char_index;

t_next_char_index += 1;

}

else if ((t_bytes[i] & 0xC0) == 0xC0)

{