/* Copyright (C) 2003-2017 LiveCode Ltd.

This file is part of LiveCode.

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

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

Software Foundation.

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

WARRANTY; without even the implied warranty of MERCHANTABILITY or

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

for more details.

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

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

#include "graphics.h"

#include "graphics-internal.h"

#import <CoreFoundation/CoreFoundation.h>

#ifdef TARGET_SUBPLATFORM_IPHONE

#import <CoreText/CoreText.h>

#import <CoreGraphics/CoreGraphics.h>

#else

#import <ApplicationServices/ApplicationServices.h>

#endif

#include <SkFont.h>

#include <SkTypeface.h>

#include <SkTypeface_mac.h>

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

static CGColorSpaceRef s_colour_space = NULL;

static CGColorRef s_text_colour = NULL;

static CGContextRef s_measure_context;

static void *s_measure_data = NULL;

void MCGPlatformInitialize(void)

{

s_colour_space = NULL;

s_text_colour = NULL;

s_measure_context = NULL;

s_measure_data = NULL;

const CGFloat t_colour_components[] = {1.0, 1.0};

#ifdef TARGET_SUBPLATFORM_IPHONE

// iOS doesn't support device-independent or generic color spaces

s_colour_space = CGColorSpaceCreateDeviceGray();

#else

s_colour_space = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);

#endif

s_text_colour = CGColorCreate(s_colour_space, t_colour_components);

/* UNCHECKED */ MCMemoryAllocate(1, s_measure_data);

s_measure_context = CGBitmapContextCreate(s_measure_data, 1, 1, 8, 1, NULL, kCGImageAlphaOnly);

}

void MCGPlatformFinalize(void)

{

if (s_text_colour != NULL)

CGColorRelease(s_text_colour);

if (s_colour_space != NULL)

CGColorSpaceRelease(s_colour_space);

if (s_measure_context != NULL)

CGContextRelease(s_measure_context);

MCMemoryDelete(s_measure_data);

s_colour_space = NULL;

s_text_colour = NULL;

s_measure_context = NULL;

s_measure_data = NULL;

}

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

// Creates an SkTypeface from a CTFontRef

static inline sk_sp<SkTypeface> MCGSkTypefaceFromCTFontRef(CTFontRef p_ref)

{

return sk_sp<SkTypeface>(SkCreateTypefaceFromCTFont(p_ref, nil));

}

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

static CTLineRef MCGCreateCTLineFromText(const unichar_t *p_text, uindex_t p_length, const MCGFont &p_font)

{

bool t_success = true;

CFStringRef t_cftext = nil;

if (t_success)

{

t_cftext = CFStringCreateWithCharacters(kCFAllocatorDefault, p_text, p_length / sizeof(unichar_t));

t_success = t_cftext != nil;

}

CFDictionaryRef t_attributes = nil;

if (t_success)

{

CTFontRef t_font = static_cast<CTFontRef>(p_font.fid);

CFStringRef t_keys[] =

{

kCTFontAttributeName,

kCTForegroundColorAttributeName,

};

CFTypeRef t_values[] =

{

t_font,

s_text_colour,

};

t_attributes = CFDictionaryCreate(NULL,

(const void **)&t_keys,

(const void **)&t_values,

sizeof(t_keys) / sizeof(t_keys[0]),

&kCFTypeDictionaryKeyCallBacks,

&kCFTypeDictionaryValueCallBacks);

t_success = t_attributes != nil;

}

CFAttributedStringRef t_attributed_text = nil;

if (t_success)

{

t_attributed_text = CFAttributedStringCreate(nil, t_cftext, t_attributes);

t_success = t_attributed_text != nil;

}

CTLineRef t_line = nil;

if (t_success)

t_line = CTLineCreateWithAttributedString(t_attributed_text);

if (t_attributed_text != NULL)

CFRelease(t_attributed_text);

if (t_attributes != NULL)

CFRelease(t_attributes);

if (t_cftext != NULL)

CFRelease(t_cftext);

return t_line;

}

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

// Wrapper used for managing glyph/position arrays

template <class T>

class MCGMaybeOwnedArray

{

public:

MCGMaybeOwnedArray(uindex_t t_length) :

m_length(t_length)

{

}

MCGMaybeOwnedArray(const MCGMaybeOwnedArray&) = delete;

~MCGMaybeOwnedArray()

{

if (m_owned)

MCMemoryDeleteArray(m_array);

}

bool TryBorrow(const T* p_array)

{

MCAssert(m_array == nil);

if (p_array != nil)

m_array = const_cast<T*>(p_array);

return p_array != nil;

}

bool Allocate()

{

MCAssert(m_array == nil);

m_owned = true;

return MCMemoryNewArray(m_length, m_array);

}

operator T* ()

{

return m_array;

}

private:

T* m_array = nil;

uindex_t m_length = 0;

bool m_owned = false;

};

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

template <class Callback>

static void MCGForEachRunInLine(CTLineRef p_line, Callback p_callback)

{

// Get the array containing the runs

CFArrayRef t_runs = CTLineGetGlyphRuns(p_line);

for (CFIndex i = 0; i < CFArrayGetCount(t_runs); i++)

{

// Get this run

CTRunRef t_run = static_cast<CTRunRef>(CFArrayGetValueAtIndex(t_runs, i));

// Execute the callback

p_callback(t_run);

}

}

template <class Callback>

static void MCGForEachGlyphInRun(CTRunRef p_run, Callback p_callback)

{

// Number of glyphs in the run

CFIndex t_length = CTRunGetGlyphCount(p_run);

// Get a copy of the glyph array

MCGMaybeOwnedArray<CGGlyph> t_glyphs(t_length);

if (!t_glyphs.TryBorrow(CTRunGetGlyphsPtr(p_run)))

{

if (t_glyphs.Allocate())

CTRunGetGlyphs(p_run, CFRangeMake(0, t_length), t_glyphs);

}

// Get a copy of the advances array

MCGMaybeOwnedArray<CGPoint> t_points(t_length);

if (!t_points.TryBorrow(CTRunGetPositionsPtr(p_run)))

{

if (t_points.Allocate())

CTRunGetPositions(p_run, CFRangeMake(0, t_length), t_points);

}

// Iterate over the contents of the glyph array

if (t_glyphs != nil && t_points != nil)

{

for (CFIndex i = 0; i < t_length; i++)

{

// Execute the callback

p_callback(t_points[i], t_glyphs[i]);

}

}

}

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

void MCGContextDrawPlatformText(MCGContextRef self, const unichar_t *p_text, uindex_t p_length, MCGPoint p_location, const MCGFont &p_font, bool p_rtl)

{

if (!MCGContextIsValid(self))

return;

// The paint containing the fill settings

SkPaint t_paint;

if (!MCGContextSetupFill(self, t_paint))

{

self->is_valid = false;

return;

}

// Only use LCD-style anti-aliasing if the layer is opaque.

t_paint.setLCDRenderText(self != nullptr ? MCGContextIsLayerOpaque(self) : true);

// Enable emoji style fonts

t_paint.setEmbeddedBitmapText(true);

// Ensure we use anti-aliasing

t_paint.setAntiAlias(true);

// Ensure we use subpixel positioning

t_paint.setSubpixelText(true);

// We are going to draw text by glyph ID rather than by codeunit

t_paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);

// Set the transform we're using

SkMatrix t_matrix;

MCGAffineTransformToSkMatrix(MCGContextGetDeviceTransform(self), t_matrix);

t_paint.setTextMatrix(&t_matrix);

// Create a fully laid-out line of text

CTLineRef t_line = MCGCreateCTLineFromText(p_text, p_length, p_font);

// Iterate over the runs of text within the line

MCGForEachRunInLine(t_line,

[=, &t_paint](CTRunRef p_run)

{

// Get the attribute dictionary for this run

CFDictionaryRef t_attributes = CTRunGetAttributes(p_run);

// Get the CTFontRef used for drawing this run

CTFontRef t_font = static_cast<CTFontRef>(CFDictionaryGetValue(t_attributes, kCTFontAttributeName));

// Calculate the origin of this run

CGAffineTransform t_text_transform = CTRunGetTextMatrix(p_run);

MCGFloat t_x = p_location.x + t_text_transform.tx;

MCGFloat t_y = p_location.y + t_text_transform.ty;

// Convert the CTFontRef into a Skia Typeface object

t_paint.setTypeface(MCGSkTypefaceFromCTFontRef(t_font));

t_paint.setTextSize(CTFontGetSize(t_font));

// Iterate through the glyphs of the run

MCGForEachGlyphInRun(p_run,

[=](CGPoint p_point, CGGlyph p_glyph)

{

// Both Skia and CG glyphs are just indices into the typeface glyph list

SkGlyphID t_glyph = p_glyph;

// Adjust the position for this glyph

MCGFloat t_glyph_x = t_x + p_point.x;

MCGFloat t_glyph_y = t_y + p_point.y;

// Finally, draw this glyph to the canvas

self->layer->canvas->drawText(&t_glyph, sizeof(t_glyph), t_glyph_x, t_glyph_y, t_paint);

});

});

// Release the typeset line

CFRelease(t_line);

}

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

MCGFloat __MCGContextMeasurePlatformText(MCGContextRef self, const unichar_t *p_text, uindex_t p_length, const MCGFont &p_font, const MCGAffineTransform &p_transform)

{

// Create a fully laid-out line of text

CTLineRef t_line =

MCGCreateCTLineFromText(p_text, p_length, p_font);

if (t_line == nullptr)

{

return 0.0;

}

MCGFloat t_width =

CTLineGetTypographicBounds(t_line, NULL, NULL, NULL);

CFRelease(t_line);

return t_width;

}

bool MCGContextMeasurePlatformTextImageBounds(MCGContextRef self, const unichar_t *p_text, uindex_t p_length, const MCGFont &p_font, const MCGAffineTransform &p_transform, MCGRectangle &r_bounds)

{

// Create a fully laid-out line of text

CTLineRef t_line =

MCGCreateCTLineFromText(p_text, p_length, p_font);

if (t_line == nullptr)

{

return 0.0;

}

CGRect t_bounds =

CTLineGetImageBounds(t_line, s_measure_context);

r_bounds = MCGRectangleMake(t_bounds.origin.x,

-(t_bounds.origin.y + t_bounds.size.height),

t_bounds.size.width,

t_bounds.size.height);

CFRelease(t_line);

return true;

}

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