/* 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 "prefix.h"

#include "core.h"

#include "globdefs.h"

#include "filedefs.h"

#include "objdefs.h"

#include "parsedef.h"

#include "osspec.h"

#include "uidc.h"

#include "mcerror.h"

#include "globals.h"

#include "execpt.h"

#include "metacontext.h"

#include "printer.h"

#include "customprinter.h"

#include "license.h"

#include "path.h"

#include "pathprivate.h"

#include "gradient.h"

#include "textlayout.h"

#include "region.h"

#include "graphicscontext.h"

#include "font.h"

#ifdef _LINUX_DESKTOP

#include "flst.h"

#endif

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

static bool MCCustomPrinterBlendModeFromInk(uint1 p_function, MCCustomPrinterBlendMode& r_mode)

{

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;

}

static bool MCCustomPrinterGradientFromMCGradient(MCGradientFillKind p_kind, MCCustomPrinterGradientType& r_type)

{

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;

}

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

static MCCustomPrinterTransform MCCustomPrinterTransformFromMCGAffineTransform(const MCGAffineTransform &p_transform)

{

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;

}

static MCCustomPrinterImageType MCCustomPrinterImageTypeFromMCGRasterFormat(MCGRasterFormat p_format)

{

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;

}

}

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

class MCCustomMetaContext: public MCMetaContext

{

public:

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);

protected:

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);

private:

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;

};

MCCustomMetaContext::MCCustomMetaContext(const MCRectangle& p_page)

: MCMetaContext(p_page)

{

m_composite_context = nil;

}

MCCustomMetaContext::~MCCustomMetaContext(void)

{

MCGContextRelease(m_composite_context);

}

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

{

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;

}

bool MCCustomMetaContext::candomark(MCMark *p_mark)

{

// 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 = MCImageBitmapHasTransparency(p_mark -> image . descriptor . bitmap, t_alpha);

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;

}

void MCCustomMetaContext::domark(MCMark *p_mark)

{

// 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:

{

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:

{

MCPath *t_path;

t_path = MCPath::create_rounded_rectangle(p_mark -> round_rectangle . bounds, p_mark -> round_rectangle . radius, 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:

{

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;

}

}

void MCCustomMetaContext::doimagemark(MCMark *p_mark)

{

// 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;

MCImageBitmap *t_img_bitmap = nil;

t_img_bitmap = p_mark -> image . descriptor . bitmap;

t_img_width = t_img_bitmap -> width;

t_img_height = t_img_bitmap -> height;

if (!m_execute_error)

{

// Fill in the printer image info

MCCustomPrinterImage t_image;

if (t_image_type == kMCCustomPrinterImageNone)

{

bool t_mask, t_alpha;

t_mask = MCImageBitmapHasTransparency(t_img_bitmap, t_alpha);

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

t_image . id = (uint32_t)(intptr_t)t_img_bitmap;

t_image . data = t_img_bitmap -> data;

t_image . data_size = t_img_bitmap -> 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.

MCGAffineTransform t_transform;

t_transform = MCGAffineTransformMakeScale(m_scale_x, m_scale_y);

t_transform = MCGAffineTransformTranslate(t_transform, m_translate_x + p_mark -> image . dx - p_mark -> image . sx, m_translate_y + 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;

}

}

void MCCustomMetaContext::dolinkmark(MCMark *p_mark)

{

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;

}

#define SCALE 4

bool MCCustomMetaContext::begincomposite(const MCRectangle &p_mark_clip, MCGContextRef &r_context)

{

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;

}

static void surface_merge_with_mask_preserve(void *p_pixels, uint4 p_pixel_stride, void *p_mask, uint4 p_mask_stride, uint4 p_offset, uint4 p_width, uint4 p_height)

{

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++;

}

}

}

void MCCustomMetaContext::endcomposite(MCRegionRef p_clip_region)

{

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);

}

void MCCustomMetaContext::dopathmark(MCMark *p_mark, MCPath *p_path)

{

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);

}

void MCCustomMetaContext::dorawpathmark(MCMark *p_mark, uint1 *p_commands, uint32_t p_command_count, int4 *p_ordinates, uint32_t p_ordinate_count, bool p_evenodd)

{

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.

MCGRaster t_tile_raster;

if (MCGImageGetRaster(p_mark -> fill -> pattern -> image, t_tile_raster))

{

// 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 . scale_x = 1.0 / p_mark -> fill -> pattern -> scale;

t_paint . pattern . transform . scale_y = 1.0 / p_mark -> fill -> pattern -> scale;

t_paint . pattern . transform . skew_x = 0.0;

t_paint . pattern . transform . skew_y = 0.0;

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

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

}

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;

}

//////////

struct dotextmark_callback_state

{

MCCustomPrintingDevice *device;

MCCustomPrinterPaint paint;

MCCustomPrinterTransform transform;

MCCustomPrinterRectangle clip;

double font_size;

};

static bool dotextmark_callback(void *p_context, const MCTextLayoutSpan *p_span)

{

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)

{

t_char_index = t_next_char_index;

if ((t_bytes[i] & 0xf0) != 0xf0)

{

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

t_next_char_index += 1;

}

else

{

// This is a 4 byte char - so it must come from a surrogate pair, i.e. 2 UTF-16 code points

t_next_char_index += 2;

}

}

t_clusters[i] = p_span -> clusters[t_char_index];

}

double t_font_size;

void *t_font_handle;

#if defined(_WINDOWS_DESKTOP)

// MW-2013-11-07: [[ Bug 10508 ]] Pass the font size into computefontsize so it can

// be scaled (layout uses 256px fonts).

extern int32_t MCCustomPrinterComputeFontSize(double size, void *font);

t_font_size = MCCustomPrinterComputeFontSize(context -> font_size, p_span -> font);

t_font_handle = p_span -> font;

#elif defined(_MAC_DESKTOP)

t_font_size = context -> font_size;

t_font_handle = p_span -> font;

#elif defined(_LINUX_DESKTOP)

t_font_size = context -> font_size;

t_font_handle = p_span -> font;

#elif defined(_IOS_MOBILE)

extern int32_t MCCustomPrinterComputeFontSize(void *font);

t_font_size = MCCustomPrinterComputeFontSize(p_span -> font);

t_font_handle = p_span -> font;

#elif defined(_SERVER)

t_font_size = 0;

t_font_handle = NULL;

#endif

MCCustomPrinterFont t_font;

t_font . size = t_font_size;

t_font . handle = t_font_handle;

bool t_success;

t_success = context -> device -> DrawText((const MCCustomPrinterGlyph *)p_span -> glyphs, p_span -> glyph_count, (const char *)t_bytes, t_clusters, t_font, context -> paint, context -> transform, context -> clip);

MCMemoryDeleteArray(t_clusters);

return t_success;

}