{

ssize_t count;

const MCGDrawingSolidColor *colors;

const MCGFloat *offsets;

{

MCGGradientSpreadMethod spread;

MCGAffineTransform transform;

MCGDrawingRamp ramp;

{

MCGPoint focal_point;

MCGFloat focal_radius;

{

kMCGDrawingPaintTypeNone,

kMCGDrawingPaintTypeSolidColor,

kMCGDrawingPaintTypeLinearGradient,

kMCGDrawingPaintTypeRadialGradient,

kMCGDrawingPaintTypeConicalGradient,

kMCGDrawingPaintTypeCurrentColor,

{

MCGDrawingPaintType type;

union

{

MCGDrawingSolidColor solid_color;

MCGDrawingGradient gradient;

MCGDrawingLinearGradient linear_gradient;

MCGDrawingRadialGradient radial_gradient;

MCGDrawingConicalGradient conical_gradient;

};

MCGDrawingPaint(void)

: type(kMCGDrawingPaintTypeNone)

{

}

{

kMCGDrawingIdent0 = 'L',

kMCGDrawingIdent1 = 'C',

kMCGDrawingIdent2 = 'D',

kMCGDrawingVersion = 0,

{

/* The drawing has a width specified which is not 100% */

kMCGDrawingHeaderFlagHasWidthBit = 1 << 0,

/* The drawing has a height specified which is not 100% */

kMCGDrawingHeaderFlagHasHeightBit = 1 << 1,

/* The drawing has a viewport specified (viewBox and preserveAspectRatio) */

kMCGDrawingHeaderFlagHasViewportBit = 1 << 2,

/* The mask to use to check no undefined flags are set. */

kMCGDrawingHeaderFlagValidMask = 0x07,

{

uint8_t ident[4];

float width;

float height;

uint32_t scalar_count;

{

/* End defines the end of an opcode stream */

kMCGDrawingOpcodeEnd = 0,

/* Transform defines a transform attribute change. The transform is defined

kMCGDrawingOpcodeTransform = 1,

/* FillPaint defines a fill-paint attribute change. The paint is defined by

kMCGDrawingOpcodeFillPaint = 2,

/* FillOpacity defines a fill-opacity attribute change. The opacity is

kMCGDrawingOpcodeFillOpacity = 3,

/* FillRule defines a fill-rule attribute change. The fill rule is defined

kMCGDrawingOpcodeFillRule = 4,

/* StrokePaint defines a stroke-paint attribute change. The paint is defined

kMCGDrawingOpcodeStrokePaint = 5,

/* StrokeOpacity defines a stroke-opacity attribute change. The opacity is

kMCGDrawingOpcodeStrokeOpacity = 6,

/* StrokeWidth defines a stroke-width attribute change. The stroke-width is

kMCGDrawingOpcodeStrokeWidth = 7,

/* StrokeLineJoin defines a stroke-line-join attribute change. The

kMCGDrawingOpcodeStrokeLineJoin = 8,

/* StrokeLineCap defines a stroke-line-cap attribute change. The

kMCGDrawingOpcodeStrokeLineCap = 9,

/* StrokeDashArray defines a stroke-dash-array attribute change. The

kMCGDrawingOpcodeStrokeDashArray = 10,

/* StrokeDashOffset defines a stroke-dash-offset attribute change. The

kMCGDrawingOpcodeStrokeDashOffset = 11,

/* StrokeMiterLimit defines a stroke-miter-limit attribute change. The

kMCGDrawingOpcodeStrokeMiterLimit = 12,

/* Rectangle defines a rectangle shape. The rectangle is defined as:

kMCGDrawingOpcodeRectangle = 13,

/* RoundedRectangle defines a rounded rectangle shape. The rounded rectangle

kMCGDrawingOpcodeRoundedRectangle = 14,

/* Circle defines a circle shape. The circle is defined as:

kMCGDrawingOpcodeCircle = 15,

/* Ellipse defines an ellipse shape. The ellipse is defined as:

kMCGDrawingOpcodeEllipse = 16,

/* Line defines a line shape. The line is defined as:

kMCGDrawingOpcodeLine = 17,

/* Polyline defines a polyline shape. The polyline is defined as an array

kMCGDrawingOpcodePolyline = 18,

/* Polyline defines a polygon shape. The polygon is defined as an array

kMCGDrawingOpcodePolygon = 19,

/* Path defines a path shape. The path is defined by a path opcode stream.

kMCGDrawingOpcodePath = 20,

/* _Last is used for range checking on the main opcodes. */

kMCGDrawingOpcode_Last = kMCGDrawingOpcodePath,

{

/* Identity defines the identity transform */

kMCGDrawingTransformOpcodeIdentity = 0,

/* Affine defines a general affine transformation. It is defined by 6

kMCGDrawingTransformOpcodeAffine = 1,

/* _Last is used for range checking on the transform opcodes. */

kMCGDrawingTransformOpcode_Last = kMCGDrawingTransformOpcodeAffine,

{

/* None defines no paint. */

kMCGDrawingPaintOpcodeNone = 0,

/* SolidColor defines a solid color paint. It is defined by 4 unit scalars -

kMCGDrawingPaintOpcodeSolidColor = 1,

/* SolidLinearGradient defines a linear gradient paint. It is defined by:

kMCGDrawingPaintOpcodeLinearGradient = 2,

kMCGDrawingPaintOpcodeRadialGradient = 3,

kMCGDrawingPaintOpcodeConicalGradient = 4,

kMCGDrawingPaintOpcodeCurrentColor = 5,

/* _Last is used for range checking on the paint opcodes. */

kMCGDrawingPaintOpcode_Last = kMCGDrawingPaintOpcodeCurrentColor,

{

kMCGDrawingSpreadMethodOpcodePad = 0,

kMCGDrawingSpreadMethodOpcodeReflect = 1,

kMCGDrawingSpreadMethodOpcodeRepeat = 2,

kMCGDrawingSpreadMethodOpcode_Last = kMCGDrawingSpreadMethodOpcodeRepeat,

{

/* NonZero indicates that the non-zero winding rule should be used. */

kMCGDrawingFillRuleOpcodeNonZero = 0,

/* EvenOdd indicates that the even-odd rule should be used. */

kMCGDrawingFillRuleOpcodeEvenOdd = 1,

/* _Last is used for range checking on the fill rule opcodes. */

kMCGDrawingFillRuleOpcode_Last = kMCGDrawingFillRuleOpcodeEvenOdd,

{

/* Bevel indicates that the bevel line join should be used. A bevel line

kMCGDrawingStrokeLineJoinOpcodeBevel = 0,

/* Round indicates that the round line join should be used. A round line

kMCGDrawingStrokeLineJoinOpcodeRound = 1,

/* Miter indicates that the miter line join should be used. A miter line

kMCGDrawingStrokeLineJoinOpcodeMiter = 2,

/* _Last is used for range checking on the line join opcodes. */

kMCGDrawingStrokeLineJoinOpcode_Last = kMCGDrawingStrokeLineJoinOpcodeMiter

{

/* Butt indicates that the butt line cap should be used. A butt line cap

kMCGDrawingStrokeLineCapOpcodeButt = 0,

/* Round indicates that the round line cap should be used. A round line cap

kMCGDrawingStrokeLineCapOpcodeRound = 1,

/* Square indicates that the square line cap should be used. A square line

kMCGDrawingStrokeLineCapOpcodeSquare = 2,

/* _Last is used for range checking on the line cap opcodes. */

kMCGDrawingStrokeLineCapOpcode_Last = kMCGDrawingStrokeLineCapOpcodeSquare

{

/* End terminates a path definition. */

kMCGDrawingPathOpcodeEnd = 0,

kMCGDrawingPathOpcodeMoveTo = 1,

kMCGDrawingPathOpcodeLineTo = 2,

kMCGDrawingPathOpcodeHorizontalTo = 3,

kMCGDrawingPathOpcodeVerticalTo = 4,

kMCGDrawingPathOpcodeCubicTo = 5,

kMCGDrawingPathOpcodeSmoothCubicTo = 6,

kMCGDrawingPathOpcodeQuadraticTo= 7,

kMCGDrawingPathOpcodeSmoothQuadraticTo = 8,

kMCGDrawingPathOpcodeArcTo = 9,

kMCGDrawingPathOpcodeReflexArcTo = 10,

kMCGDrawingPathOpcodeReverseArcTo = 11,

kMCGDrawingPathOpcodeReverseReflexArcTo = 12,

kMCGDrawingPathOpcodeCloseSubpath = 13,

kMCGDrawingPathOpcode_Last = kMCGDrawingPathOpcodeCloseSubpath,

{

switch(p_opcode)

{

case kMCGDrawingPathOpcodeReflexArcTo:

case kMCGDrawingPathOpcodeReverseReflexArcTo:

return true;

default:

break;

}

return false;

{

switch(p_opcode)

{

case kMCGDrawingPathOpcodeReverseArcTo:

case kMCGDrawingPathOpcodeReverseReflexArcTo:

return true;

default:

break;

}

return false;

{

/* Path Operations */

void PathBegin(void);

void PathMoveTo(bool is_relative, MCGPoint p_point);

void PathLineTo(bool is_relative, MCGPoint p_point);

void PathHorizontalTo(bool is_relative, MCGFloat x);

void PathVerticalTo(bool is_relative, MCGFloat y);

void PathCubicTo(bool is_relative, MCGPoint p_a, MCGPoint p_b, MCGPoint p_point);

void PathSmoothCubicTo(bool is_relative, MCGPoint p_b, MCGPoint p_point);

void PathQuadraticTo(bool is_relative, MCGPoint p_a, MCGPoint p_point);

void PathSmoothQuadraticTo(bool is_relative, MCGPoint p_point);

void PathArcTo(bool is_relative, bool is_reflex, bool is_reverse, MCGPoint p_center, MCGFloat rotation, MCGPoint p_point);

void PathCloseSubpath(void);

void PathEnd(void);

/* General Attribute Operations */

void Transform(MCGAffineTransform transform);

/* Fill Attribute Operations */

void FillPaint(const MCGDrawingPaint& paint);

void FillOpacity(MCGFloat opacity);

void FillRule(MCGFillRule fill_rule);

/* Stroke Attribute Operations */

void StrokePaint(const MCGDrawingPaint& paint);

void StrokeOpacity(MCGFloat opacity);

void StrokeWidth(MCGFloat width);

void StrokeLineJoin(MCGJoinStyle join_style);

void StrokeLineCap(MCGCapStyle cap_style);

void StrokeDashArray(MCSpan<const MCGFloat> lengths);

void StrokeDashOffset(MCGFloat offset);

void StrokeMiterLimit(MCGFloat miter_limit);

/* Shape Operations */

void Rectangle(MCGRectangle p_bounds, MCGPoint p_radii);

void Circle(MCGPoint p_center, MCGFloat r);

void Ellipse(MCGPoint p_center, MCGSize p_radii);

void Line(MCGPoint p_from, MCGPoint p_to);

void Polyline(MCSpan<const MCGPoint> p_points);

void Polygon(MCSpan<const MCGPoint> p_points);

/* Lifecycle Operations */

void Start(MCGRectangle p_src_rect, MCGRectangle p_dst_rect);

void Finish(bool p_error);

{

/* None indicates that there are no problems with the drawing so far. */

kMCGDrawingStatusNone,

/* InvalidDrawing indicates that the drawing data is malformed and cannot

kMCGDrawingStatusInvalidDrawing,

/* InvalidIdent indicates that the 3 main ident bytes do not match 'LCD'. */

kMCGDrawingStatusInvalidIdent,

/* InvalidVersion indicates that the version is not recognised. */

kMCGDrawingStatusInvalidVersion,

/* InvalidWidth indicates that the width field is not a valid value. */

kMCGDrawingStatusInvalidWidth,

/* InvalidHeight indicates that the height field is not a valid value. */

kMCGDrawingStatusInvalidHeight,

/* ScalarOverflow indicates that more scalars are required than are present.

kMCGDrawingStatusScalarOverflow,

/* OpcodeOverflow indicates that more opcodes are required than are present.

kMCGDrawingStatusOpcodeOverflow,

/* InvalidOpcode indicates that an undefined main opcode has been

kMCGDrawingStatusInvalidOpcode,

/* InvalidPathOpcode indicates that an undefined path opcode has been

kMCGDrawingStatusInvalidPathOpcode

,

/* InvalidPaintOpcode indicates that an undefined paint opcode has been

kMCGDrawingStatusInvalidPaintOpcode,

/* InvalidTransformOpcode indicates that an undefined transform opcode has

kMCGDrawingStatusInvalidTransformOpcode,

/* InvalidFillRuleOpcode indicates that an undefined fill rule opcode has

kMCGDrawingStatusInvalidFillRuleOpcode,

/* InvalidStrokeLineJoinOpcode indicates that an undefined line join opcode

kMCGDrawingStatusInvalidStrokeLineJoinOpcode,

/* InvalidStrokeLineCapOpcode indicates that an undefined line cap opcode

kMCGDrawingStatusInvalidStrokeLineCapOpcode,

/* InvalidSpreadMethodOpcode indicates that an undefined spread method

kMCGDrawingStatusInvalidSpreadMethodOpcode,

/* InvalidPointArray indicates that a point array with an odd number of

kMCGDrawingStatusInvalidPointArray,

{

MCGDrawingByteStream(MCSpan<const byte_t> p_bytes)

: m_bytes(p_bytes)

{

}

/* Returns true if there are no more bytes to process. */

bool IsFinished(void) const

{

return m_bytes.empty();

}

/* Singleton attempts to unpack a single field of type T. It returns true

template<typename T>

bool Singleton(T& r_singleton)

{

ssize_t t_singleton_size = sizeof(T);

if (m_bytes.size() < t_singleton_size)

{

return false;

}

auto t_singleton_ptr = reinterpret_cast<const T *>(m_bytes.data());

r_singleton = *t_singleton_ptr;

m_bytes = m_bytes.subspan(t_singleton_size);

return true;

}

/* Array attempts to unpack p_count fields of type T. It returns true if

template<typename T>

bool Sequence(MCSpan<const T>& r_sequence)

{

uint32_t t_size;

if (!Singleton(t_size))

{

return false;

}

ssize_t t_byte_size = t_size * sizeof(T);

if (m_bytes.size() < t_byte_size)

{

return false;

}

auto t_seq_ptr = reinterpret_cast<const T *>(m_bytes.data());

r_sequence = MCMakeSpan(t_seq_ptr, t_size);

m_bytes = m_bytes.subspan(t_byte_size);

return true;

}

MCSpan<const byte_t> m_bytes;

{

/* MCGDrawingContext is the main constructor. It attempts to unpack the

MCGDrawingContext(MCSpan<const byte_t> p_bytes)

{

MCGDrawingByteStream t_stream(p_bytes);

/* Unpack the header. If the size of the provided data does not match

uint8_t t_ident_0, t_ident_1, t_ident_2, t_ident_version;

if (!t_stream.Singleton(t_ident_0) ||

!t_stream.Singleton(t_ident_1) ||

!t_stream.Singleton(t_ident_2) ||

!t_stream.Singleton(t_ident_version) ||

!t_stream.Singleton(m_width) ||

!t_stream.Singleton(m_height) ||

!t_stream.Sequence(m_scalars) ||

!t_stream.Sequence(m_opcodes) ||

!t_stream.IsFinished())

{

m_status = kMCGDrawingStatusInvalidDrawing;

return;

}

/* Check the ident field is correct. */

if (t_ident_0 != kMCGDrawingIdent0 ||

t_ident_1 != kMCGDrawingIdent1 ||

t_ident_2 != kMCGDrawingIdent2)

{

m_status = kMCGDrawingStatusInvalidIdent;

return;

}

/* Check the version field is correct. */

if (t_ident_version != kMCGDrawingVersion)

{

m_status = kMCGDrawingStatusInvalidVersion;

return;

}

/* Check the width is valid. */

if (m_width < 0)

{

m_status = kMCGDrawingStatusInvalidWidth;

return;

}

/* Check the height is valid. */

if (m_height < 0)

{

m_status = kMCGDrawingStatusInvalidHeight;

return;

}

}

/* IsRunning() returns true if the execution has encountered no problems.

bool IsRunning(void) const

{

return m_status == kMCGDrawingStatusNone;

}

/* Opcode attempts to read the next opcode as a main opcode. */

bool Opcode(MCGDrawingOpcode& r_opcode)

{

return GeneralOpcode<MCGDrawingOpcode,

kMCGDrawingOpcode_Last,

kMCGDrawingStatusInvalidOpcode>(r_opcode);

}

/* TransformOpcode attempts to read the next opcode as a transform opcode. */

bool TransformOpcode(MCGDrawingTransformOpcode& r_opcode)

{

return GeneralOpcode<MCGDrawingTransformOpcode,

kMCGDrawingTransformOpcode_Last,

kMCGDrawingStatusInvalidTransformOpcode>(r_opcode);

}

/* PaintOpcode attempts to read the next opcode as a paint opcode. */

bool PaintOpcode(MCGDrawingPaintOpcode& r_opcode)

{

return GeneralOpcode<MCGDrawingPaintOpcode,

kMCGDrawingPaintOpcode_Last,

kMCGDrawingStatusInvalidPaintOpcode>(r_opcode);

}

/* PathOpcode attempts to read the next opcode as a path opcode. */

bool PathOpcode(MCGDrawingPathOpcode& r_opcode)

{

return GeneralOpcode<MCGDrawingPathOpcode,

kMCGDrawingPathOpcode_Last,

kMCGDrawingStatusInvalidPathOpcode>(r_opcode);

}

/* FillRuleOpcode attempts to read the next opcode as a fill rule opcode. */

bool FillRuleOpcode(MCGDrawingFillRuleOpcode& r_opcode)

{

return GeneralOpcode<MCGDrawingFillRuleOpcode,

kMCGDrawingFillRuleOpcode_Last,

kMCGDrawingStatusInvalidFillRuleOpcode>(r_opcode);

}

/* StrokeLineJoin attempts to read the next opcode as a line join opcode. */

bool StrokeLineJoinOpcode(MCGDrawingStrokeLineJoinOpcode& r_opcode)

{

return GeneralOpcode<MCGDrawingStrokeLineJoinOpcode,

kMCGDrawingStrokeLineJoinOpcode_Last,

kMCGDrawingStatusInvalidStrokeLineJoinOpcode>(r_opcode);

}

/* StrokeLineCape attempts to read the next opcode as a line cap opcode. */

bool StrokeLineCapOpcode(MCGDrawingStrokeLineCapOpcode& r_opcode)

{

return GeneralOpcode<MCGDrawingStrokeLineCapOpcode,

kMCGDrawingStrokeLineCapOpcode_Last,

kMCGDrawingStatusInvalidStrokeLineCapOpcode>(r_opcode);

}

/* SpreadMethodOpcode attempts to read the next opcode as a spread method

bool SpreadMethodOpcode(MCGDrawingSpreadMethodOpcode& r_opcode)

{

return GeneralOpcode<MCGDrawingSpreadMethodOpcode,

kMCGDrawingSpreadMethodOpcode_Last,

kMCGDrawingStatusInvalidSpreadMethodOpcode>(r_opcode);

}

/* Count attempts to read an non-negative integer from the opcode stream.

bool Count(ssize_t& r_count)

{

/* Start the read count at zero, each byte will be accumulated into it

ssize_t t_count = 0;

/* Opcode bytes are processed until we reach a termination condition. */

for(;;)

{

/* If the end of the opcode stream is reached, then indicate

if (m_pc == m_opcodes.size())

{

m_status = kMCGDrawingStatusOpcodeOverflow;

return false;

}

/* Fetch the next limb of the integer and increment the pc. */

uint8_t t_next_limb = m_opcodes[m_pc++];

/* Accumulate the limb into the current count, making sure to mask

t_count = (t_count << 8) | (t_next_limb & 0x7f);

/* If the top bit of the limb is zero, then the integer is complete.

if ((t_next_limb & 0x40) == 0)

{

break;

}

}

/* Return the accumulated integer. */

r_count = t_count;

return true;

}

/* Scalar attempts to read the next scalar from the scalar stream. If the

bool Scalar(MCGFloat& r_scalar)

{

/* If the scalar counter is at the end of the scalar stream, then

if (m_sc == m_scalars.size())

{

m_status = kMCGDrawingStatusScalarOverflow;

return false;

}

/* Place the next scalar in r_scalar and increment the scalar counter. */

r_scalar = m_scalars[m_sc++];

return true;

}

/* Scalars attempts to read p_count scalars from the scalar stream. If there

bool Scalars(ssize_t p_count, MCSpan<const MCGFloat>& r_scalars)

{

/* If there are not enough scalars left to satisfy the request then

if (m_sc + p_count > m_scalars.size())

{

m_status = kMCGDrawingStatusScalarOverflow;

return false;

}

/* Place the base of the scalar array in r_scalars. */

r_scalars = m_scalars.subspan(m_sc, p_count);

/* Increment the scalar counter */

m_sc += p_count;

return true;

}

bool UnitScalars(ssize_t p_count, MCSpan<const MCGFloat>& r_scalars)

{

return Scalars(p_count, r_scalars);

}

/* LengthScalars attempts to read p_count length scalars - a length scalar

bool LengthScalars(ssize_t p_count, MCSpan<const MCGFloat>& r_scalars)

{

return Scalars(p_count, r_scalars);

}

/* CoordinateScalars attempts to read p_count coordinate scalars. */

bool CoordinateScalars(ssize_t p_count, MCSpan<const MCGFloat>& r_scalars)

{

return Scalars(p_count, r_scalars);

}

/* Coordinate scalar attempte to read a single coordinate scalar. */

bool CoordinateScalar(MCGFloat& r_coord_scalar)

{

return Scalar(r_coord_scalar);

}

/* UnitScalar attempts to read a single unit scalar - a unit scalar is a

bool UnitScalar(MCGFloat& r_unit_scalar)

{

return Scalar(r_unit_scalar);

}

/* LengthScalar attempts to read a single length scalar. */

bool LengthScalar(MCGFloat& r_length_scalar)

{

return Scalar(r_length_scalar);

}

/* PositiveScalar attempts to read a single positive scalar - a positive

bool PositiveScalar(MCGFloat& r_positive_scalar)

{

return Scalar(r_positive_scalar);

}

/* AngleScalar attempts to read a single angle scalar. */

bool AngleScalar(MCGFloat& r_angle_scalar)

{

return Scalar(r_angle_scalar);

}

/* Point attempts to read a point defined as two coordinate scalars - x y. */

bool Point(MCGPoint& r_point)

{

if (!CoordinateScalar(r_point.x) ||

!CoordinateScalar(r_point.y))

{

return false;

}

return true;

}

/* Size attempts to read a size defined as two length scalars - rx ry. */

bool Size(MCGSize& r_size)

{

if (!LengthScalar(r_size.width) ||

!LengthScalar(r_size.height))

{

return false;

}

return true;

}

/* AffineTransform attempts to read an transform defined as size scalars. */

bool AffineTransform(MCGAffineTransform& r_transform)

{

if (!Scalar(r_transform.a) ||

!Scalar(r_transform.b) ||

!Scalar(r_transform.c) ||

!Scalar(r_transform.d) ||

!Scalar(r_transform.tx) ||

!Scalar(r_transform.ty))

{

return false;

}

return true;

}

/* Rectangle attempts to read a rectangle defined as four scalars - x, y

bool Rectangle(MCGRectangle& r_rect)

{

if (!CoordinateScalar(r_rect.origin.x) ||

!CoordinateScalar(r_rect.origin.y) ||

!LengthScalar(r_rect.size.width) ||

!LengthScalar(r_rect.size.height))

{

return false;

}

return true;

}

/* SolidColor attempts to read a solid color defined as three unit scalars -

bool SolidColor(MCGDrawingSolidColor& r_color)

{

if (!UnitScalar(r_color.red) ||

!UnitScalar(r_color.green) ||

!UnitScalar(r_color.blue) ||

!UnitScalar(r_color.alpha))

{

return false;

}

return true;

}

/* LengthArray attempts to read an array of scalars, using a count fetched

bool LengthArray(MCSpan<const MCGFloat>& r_lengths)

{

ssize_t t_count;

if (!Count(t_count))

{

return false;

}

if (!Scalars(t_count, r_lengths))

{

return false;

}

return true;

}

/* PointArray attempts to read an array of coordinate scalar pairs, using