/* Copyright (C) 2003-2015 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"

#include <atomic>

#include <dwrite.h>

#include <SkFont.h>
#include <SkTypeface.h>
#include <SkTypeface_win.h>
#include <SkTypeface_win_dw.h>

#pragma comment(lib, "DWrite")

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

// Class implementing the DirectWrite renderer interface
template <class Callback>
class MCGDWRenderer : 
	public IDWriteTextRenderer
{
public:

	MCGDWRenderer(Callback p_callback) :
		m_callback(p_callback)
	{
	}

	// IUnknown
	STDMETHOD_(ULONG, AddRef)();
	STDMETHOD_(ULONG, Release)();
	STDMETHOD(QueryInterface)(REFIID, void**);

	// IDWritePixelSnapping
	STDMETHOD(GetCurrentTransform)(void*, DWRITE_MATRIX*);
	STDMETHOD(GetPixelsPerDip)(void*, FLOAT*);
	STDMETHOD(IsPixelSnappingDisabled)(void*, BOOL*);

	// IDWriteTextRenderer
	STDMETHOD(DrawGlyphRun)(void*, FLOAT, FLOAT, DWRITE_MEASURING_MODE, const DWRITE_GLYPH_RUN*, const DWRITE_GLYPH_RUN_DESCRIPTION*, IUnknown*);
	STDMETHOD(DrawInlineObject)(void*, FLOAT, FLOAT, IDWriteInlineObject*, BOOL, BOOL, IUnknown*);
	STDMETHOD(DrawStrikethrough)(void*, FLOAT, FLOAT, const DWRITE_STRIKETHROUGH*, IUnknown*);
	STDMETHOD(DrawUnderline)(void*, FLOAT, FLOAT, const DWRITE_UNDERLINE*, IUnknown*);

private:

	std::atomic<ULONG> m_refcount = 1;
	Callback m_callback;
};

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

template <class Callback>
STDMETHODIMP_(ULONG) MCGDWRenderer<Callback>::AddRef()
{
	return ++m_refcount;
}

template <class Callback>
STDMETHODIMP_(ULONG) MCGDWRenderer<Callback>::Release()
{
	ULONG t_remaining = --m_refcount;
	if (t_remaining == 0)
		delete this;

	return t_remaining;
}

template <class Callback>
STDMETHODIMP MCGDWRenderer<Callback>::QueryInterface(REFIID riid, void** ppvObject)
{
	if (riid == __uuidof(IUnknown) || riid == __uuidof(IDWritePixelSnapping) || riid == __uuidof(IDWriteTextRenderer))
	{
		*ppvObject = this;
		return S_OK;
	}

	// Not a recognised interface
	return E_NOINTERFACE;
}

template <class Callback>
STDMETHODIMP MCGDWRenderer<Callback>::GetCurrentTransform(void* context, DWRITE_MATRIX* transform)
{
	// Get the graphics context
	MCGContextRef t_context = static_cast<MCGContextRef>(context);

	// Get the transform used for drawing
	MCGAffineTransform t_transform = MCGContextGetDeviceTransform(t_context);

	// Translate to the DirectWrite matrix format
	transform->m11 = t_transform.a;
	transform->m12 = t_transform.b;
	transform->m21 = t_transform.c;
	transform->m22 = t_transform.d;
	transform->dx  = t_transform.tx;
	transform->dy  = t_transform.ty;

	return S_OK;
}

template <class Callback>
STDMETHODIMP MCGDWRenderer<Callback>::GetPixelsPerDip(void* context, FLOAT* pixelsPerDip)
{
	// Get the graphics context
	MCGContextRef t_context = static_cast<MCGContextRef>(context);

	// Get the transform being used for drawing
	MCGAffineTransform t_transform = MCGContextGetDeviceTransform(t_context);
	
	// The scale factor can be derived from the transform
	*pixelsPerDip = sqrt((t_transform.a*t_transform.a
						+ t_transform.b*t_transform.b
						+ t_transform.c*t_transform.c
						+ t_transform.d*t_transform.d) / 2);
	
	return S_OK;
}

template <class Callback>
STDMETHODIMP MCGDWRenderer<Callback>::IsPixelSnappingDisabled(void* context, BOOL* isDisabled)
{
	// DirectWrite recommends this be enabled unless there is a good reason to disable it
	*isDisabled = TRUE;
	return S_OK;
}

template <class Callback>
STDMETHODIMP MCGDWRenderer<Callback>::DrawGlyphRun(void* context, FLOAT baselineOriginX, FLOAT baselineOriginY, DWRITE_MEASURING_MODE measuringMode, const DWRITE_GLYPH_RUN* glyphRun, const DWRITE_GLYPH_RUN_DESCRIPTION* glyphRunDescription, IUnknown* clientDrawingEffect)
{
	// Forward to the callback
	m_callback(baselineOriginX, baselineOriginY, measuringMode, glyphRun, glyphRunDescription);
	return S_OK;
}

template <class Callback>
STDMETHODIMP MCGDWRenderer<Callback>::DrawInlineObject(void* context, FLOAT originX, FLOAT originY, IDWriteInlineObject* inlineObject, BOOL isSideways, BOOL isRightToLeft, IUnknown* clientDrawingEffect)
{
	// Ignored
	return S_OK;
}

template <class Callback>
STDMETHODIMP MCGDWRenderer<Callback>::DrawStrikethrough(void* context, FLOAT baselineOriginX, FLOAT baselineOriginY, const DWRITE_STRIKETHROUGH* strikethrough, IUnknown* clientDrawingEffect)
{
	// Ignored
	return S_OK;
}

template <class Callback>
STDMETHODIMP MCGDWRenderer<Callback>::DrawUnderline(void* context, FLOAT baselineOriginX, FLOAT baselineOriginY, const DWRITE_UNDERLINE* underline, IUnknown* clientDrawingRect)
{
	// Ignored
	return S_OK;
}

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

class MCGDWFontCollectionLoader :
	public IDWriteFontCollectionLoader
{
public:
	// IUnknown
	STDMETHOD_(ULONG, AddRef)();
	STDMETHOD_(ULONG, Release)();
	STDMETHOD(QueryInterface)(REFIID, void**);

	// IDWriteFontCollectionLoader
	STDMETHOD(CreateEnumeratorFromKey)(IDWriteFactory* factory, void const* collectionKey, UINT32 collectionKeySize, IDWriteFontFileEnumerator** fontFileEnumerator);

private:
	std::atomic<ULONG> m_refcount = 1;
};

class MCGDWFontFileEnumerator :
	public IDWriteFontFileEnumerator
{
public:
	MCGDWFontFileEnumerator(IDWriteFactory *factory, MCProperListRef files);
	~MCGDWFontFileEnumerator();

	// IUnknown
	STDMETHOD_(ULONG, AddRef)();
	STDMETHOD_(ULONG, Release)();
	STDMETHOD(QueryInterface)(REFIID, void**);

	// IDWriteFontFileEnumerator
	STDMETHOD(MoveNext)(BOOL* hasCurrentFile);
	STDMETHOD(GetCurrentFontFile)(IDWriteFontFile** fontFile);

private:
	MCProperListRef m_files;
	uindex_t m_file_index;

	IDWriteFontFile *m_current_file;
	IDWriteFactory *m_factory;
	std::atomic<ULONG> m_refcount = 1;
};

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

// IUnknown
STDMETHODIMP_(ULONG) MCGDWFontCollectionLoader::AddRef()
{
	return ++m_refcount;
}

STDMETHODIMP_(ULONG) MCGDWFontCollectionLoader::Release()
{
	ULONG t_remaining = --m_refcount;
	if (t_remaining == 0)
		delete this;

	return t_remaining;
}

STDMETHODIMP MCGDWFontCollectionLoader::QueryInterface(REFIID riid, void **ppvObject)
{
	if (riid == __uuidof(IUnknown) || riid == __uuidof(IDWriteFontCollectionLoader))
	{
		*ppvObject = this;
		return S_OK;
	}

	return E_NOINTERFACE;
}

// IDWriteFontCollectionLoader
STDMETHODIMP MCGDWFontCollectionLoader::CreateEnumeratorFromKey(IDWriteFactory* factory, void const* collectionKey, UINT32 collectionKeySize, IDWriteFontFileEnumerator** fontFileEnumerator)
{
	MCProperListRef t_font_files = *static_cast<MCProperListRef const*>(collectionKey);
	MCAssert(collectionKeySize == sizeof(MCProperListRef));
	MCAssert(MCValueGetTypeCode(t_font_files) == kMCValueTypeCodeProperList);

	MCGDWFontFileEnumerator *t_enum = new(std::nothrow) MCGDWFontFileEnumerator(factory, t_font_files);
	if (t_enum == nil)
		return E_OUTOFMEMORY;

	*fontFileEnumerator = t_enum;
	return S_OK;
}

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

MCGDWFontFileEnumerator::MCGDWFontFileEnumerator(IDWriteFactory *p_factory, MCProperListRef p_files)
{
	m_current_file = nil;

	m_factory = p_factory;
	p_factory->AddRef();

	m_files = MCValueRetain(p_files);
	m_file_index = 0;
}

MCGDWFontFileEnumerator::~MCGDWFontFileEnumerator()
{
	m_factory->Release();
	MCValueRelease(m_files);

	if (m_current_file != nil)
		m_current_file->Release();
}

// IUnknown
STDMETHODIMP_(ULONG) MCGDWFontFileEnumerator::AddRef()
{
	return ++m_refcount;
}

STDMETHODIMP_(ULONG) MCGDWFontFileEnumerator::Release()
{
	ULONG t_remaining = --m_refcount;
	if (t_remaining == 0)
		delete this;

	return t_remaining;
}

STDMETHODIMP MCGDWFontFileEnumerator::QueryInterface(REFIID riid, void **ppvObject)
{
	if (riid == __uuidof(IUnknown) || riid == __uuidof(IDWriteFontFileEnumerator))
	{
		*ppvObject = this;
		return S_OK;
	}

	return E_NOINTERFACE;
}

// IDWriteFontFileEnumerator
STDMETHODIMP MCGDWFontFileEnumerator::MoveNext(BOOL *r_has_current_file)
{
	if (m_file_index >= MCProperListGetLength(m_files))
	{
		*r_has_current_file = FALSE;
		return S_OK;
	}

	MCStringRef t_fname;
	t_fname = static_cast<MCStringRef>(MCProperListFetchElementAtIndex(m_files, m_file_index));

	MCAssert(MCValueGetTypeCode(t_fname) == kMCValueTypeCodeString);

	MCAutoStringRefAsUTF16String t_utf16_fname;
	if (!t_utf16_fname.Lock(t_fname))
		return E_OUTOFMEMORY;

	IDWriteFontFile *t_font_file = nil;

	HRESULT t_result;
	t_result = m_factory->CreateFontFileReference(t_utf16_fname.Ptr(), NULL, &t_font_file);

	if (!SUCCEEDED(t_result))
		return t_result;

	m_file_index++;

	if (m_current_file != nil)
		m_current_file->Release();

	m_current_file = t_font_file;
	*r_has_current_file = TRUE;

	return t_result;
}

STDMETHODIMP MCGDWFontFileEnumerator::GetCurrentFontFile(IDWriteFontFile **r_current_file)
{
	if (m_current_file == nil)
		return E_FAIL;

	*r_current_file = m_current_file;
	m_current_file->AddRef();

	return S_OK;
}

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

// Factory object for creating DirectWrite objects
static IDWriteFactory* s_DWFactory = nil;

// Custom loader for non-system fonts
static IDWriteFontCollectionLoader* s_DWFontCollectionLoader = nil;
// Custom font collection
static IDWriteFontCollection* s_DWFontCollection = nil;
// Set of custom fonts used by loader
static MCProperListRef s_FontFiles = nil;

// GDI interoperation object
static IDWriteGdiInterop* s_GdiInterop = nil;

// DirectWrite text analyser object
static IDWriteTextAnalyzer* s_DWTextAnalyzer = nil;

void MCGPlatformInitialize(void)
{
	bool t_success = true;

	// Create the DirectWrite factory object
	if (t_success)
		t_success = SUCCEEDED(DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), reinterpret_cast<IUnknown**>(&s_DWFactory)));

	// Create the GDI interoperation object
	if (t_success)
		t_success = SUCCEEDED(s_DWFactory->GetGdiInterop(&s_GdiInterop));

	// Create the DirectWrite text analyser
	if (t_success)
		t_success = SUCCEEDED(s_DWFactory->CreateTextAnalyzer(&s_DWTextAnalyzer));

	if (t_success)
		t_success = nil != (s_DWFontCollectionLoader = new(std::nothrow) MCGDWFontCollectionLoader());

	if (t_success)
		t_success = SUCCEEDED(s_DWFactory->RegisterFontCollectionLoader(s_DWFontCollectionLoader));

	if (t_success)
		s_FontFiles = MCValueRetain(kMCEmptyProperList);
}

void MCGPlatformFinalize(void)
{
	// Release the custom font list
	if (s_FontFiles)
		MCValueRelease(s_FontFiles);

	// Release the custom font collection
	if (s_DWFontCollection)
		s_DWFontCollection->Release();

	// Release the custom font loader
	if (s_DWFontCollectionLoader)
	{
		s_DWFactory->UnregisterFontCollectionLoader(s_DWFontCollectionLoader);
		s_DWFontCollectionLoader->Release();
	}

	// Release the text analyser
	if (s_DWTextAnalyzer)
		s_DWTextAnalyzer->Release();
	
	// Release the GDI interop object
	if (s_GdiInterop)
		s_GdiInterop->Release();

	// Release the DirectWrite factory object
	if (s_DWFactory)
		s_DWFactory->Release();
}

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

bool MCGDWSetFontFiles(MCProperListRef p_files)
{
	IDWriteFontCollection *t_new_collection = nil;
	if (!SUCCEEDED(s_DWFactory->CreateCustomFontCollection(s_DWFontCollectionLoader, &p_files, sizeof(MCProperListRef), &t_new_collection)))
		return false;

	MCValueAssign(s_FontFiles, p_files);

	if (s_DWFontCollection)
		s_DWFontCollection->Release();

	s_DWFontCollection = t_new_collection;

	return true;
}

bool MCGFontAddPlatformFileResource(MCStringRef p_file)
{
	uindex_t t_offset;
	if (MCProperListFirstIndexOfElement(s_FontFiles, p_file, 0, t_offset))
		/* Font file already in collection */
		return true;

	MCAutoProperListRef t_files;
	if (!MCProperListMutableCopy(s_FontFiles, &t_files))
		return false;

	if (!MCProperListPushElementOntoBack(*t_files, p_file))
		return false;

	return MCGDWSetFontFiles(*t_files);
}

bool MCGFontRemovePlatformFileResource(MCStringRef p_file)
{
	uindex_t t_offset;
	if (!MCProperListFirstIndexOfElement(s_FontFiles, p_file, 0, t_offset))
		/* Font file not in collection */
		return true;

	MCAutoProperListRef t_files;
	if (!MCProperListMutableCopy(s_FontFiles, &t_files))
		return false;

	if (!MCProperListRemoveElement(*t_files, t_offset))
		return false;

	return MCGDWSetFontFiles(*t_files);
}

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

static bool MCGDWGetDefaultLocalizedString(IDWriteLocalizedStrings *p_strings, MCStringRef &r_string)
{
	UINT32 t_index = 0;
	BOOL t_found = FALSE;
	if (!SUCCEEDED(p_strings->FindLocaleName(L"en-us", &t_index, &t_found)))
		return false;

	// Fallback to first name in list
	if (!t_found)
		t_index = 0;

	UINT32 t_name_length;
	if (!SUCCEEDED(p_strings->GetStringLength(t_index, &t_name_length)))
		return false;

	MCAutoArray<WCHAR> t_buffer;
	if (!t_buffer.New(t_name_length + 1))
		return false;
	if (!SUCCEEDED(p_strings->GetString(t_index, t_buffer.Ptr(), t_name_length + 1)))
		return false;

	return MCStringCreateWithWString(t_buffer.Ptr(), r_string);
}

static bool MCGDWAddCollectionFontsToList(IDWriteFontCollection *p_collection, MCProperListRef p_list)
{
	if (p_collection == nil)
		return true;

	bool t_success = true;

	UINT32 t_count;
	t_count = p_collection->GetFontFamilyCount();

	for (uint32_t i = 0; t_success && i < t_count; i++)
	{
		IDWriteFontFamily *t_family = nil;
		t_success = SUCCEEDED(p_collection->GetFontFamily(i, &t_family));

		IDWriteLocalizedStrings *t_names = nil;
		if (t_success)
			t_success = SUCCEEDED(t_family->GetFamilyNames(&t_names));

		MCAutoStringRef t_name;
		if (t_success)
			t_success = MCGDWGetDefaultLocalizedString(t_names, &t_name);

		if (t_success)
			t_success = MCProperListPushElementOntoBack(p_list, *t_name);

		if (t_names != nil)
			t_names->Release();
		if (t_family != nil)
			t_family->Release();
	}
}

bool MCGFontGetPlatformFontList(MCProperListRef &r_fonts)
{
	bool t_success = true;

	MCAutoProperListRef t_fonts;
	t_success = MCProperListCreateMutable(&t_fonts);

	IDWriteFontCollection *t_system_collection = nil;
	if (t_success)
		t_success = SUCCEEDED(s_DWFactory->GetSystemFontCollection(&t_system_collection));
	if (t_success)
		t_success = MCGDWAddCollectionFontsToList(t_system_collection, *t_fonts);

	if (t_success && s_DWFontCollection != nil)
		t_success = MCGDWAddCollectionFontsToList(s_DWFontCollection, *t_fonts);

	if (t_success)
		r_fonts = t_fonts.Take();

	return t_success;
}

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

// Creates a DirectWrite text format object from an HFONT
static IDWriteTextFormat* MCGDWTextFormatFromHFONT(HFONT p_hfont, MCGFloat p_size)
{
	// Get the LOGFONT information for the given HFONT
	// Note that we don't trust the height from this as it is the cell height, not "normal" height
	LOGFONTW t_logfont;
	GetObjectW(p_hfont, sizeof(LOGFONTW), &t_logfont);

	// Extract the important parameters
	// Note: same weight values in GDI and DirectWrite
	DWRITE_FONT_WEIGHT t_font_weight = static_cast<DWRITE_FONT_WEIGHT>(t_logfont.lfWeight);
	DWRITE_FONT_STRETCH t_font_stretch = DWRITE_FONT_STRETCH_NORMAL;
	FLOAT t_font_size = p_size;
	DWRITE_FONT_STYLE t_font_style = DWRITE_FONT_STYLE_NORMAL;
	if (t_logfont.lfItalic)
		t_font_style = DWRITE_FONT_STYLE_ITALIC;
	else if (t_logfont.lfOrientation > 0)
		t_font_style = DWRITE_FONT_STYLE_OBLIQUE;

	// Create the text format object
	IDWriteTextFormat* t_format = nil;
	// First try custom font collection, then fall back to system collection
	if (s_DWFontCollection != nil)
	{
		UINT32 t_index = 0;
		BOOL t_found = FALSE;

		s_DWFontCollection->FindFamilyName(t_logfont.lfFaceName, &t_index, &t_found);
		if (t_found && SUCCEEDED(s_DWFactory->CreateTextFormat(t_logfont.lfFaceName, s_DWFontCollection, t_font_weight, t_font_style, t_font_stretch, t_font_size, L"en-us", &t_format)))
			return t_format;
	}

	if (!SUCCEEDED(s_DWFactory->CreateTextFormat(t_logfont.lfFaceName, nil, t_font_weight, t_font_style, t_font_stretch, t_font_size, L"en-us", &t_format)))
		return nil;

	return t_format;
}

// Creates an SkPaint from a DirectWrite font face
static inline void MCGSkPaintFromDWFontFace(IDWriteFontFace* p_face, FLOAT p_emsize, const MCGAffineTransform& p_transform, SkPaint& x_paint)
{
	// Map from font face to font (requires the font collection containing the font)
	// Search the custom collection for the font
	IDWriteFont* t_font = nil;
	if (s_DWFontCollection != nil)
		s_DWFontCollection->GetFontFromFontFace(p_face, &t_font);

	if (t_font == nil)
	{
		// Fallback to checking system font collection
		IDWriteFontCollection *t_sys_collection = nil;
		s_DWFactory->GetSystemFontCollection(&t_sys_collection);
		t_sys_collection->GetFontFromFontFace(p_face, &t_font);
		t_sys_collection->Release();
	}
	// Get the family from the font
	IDWriteFontFamily* t_family;
	t_font->GetFontFamily(&t_family);
	
	// Create a Skia typeface from the DirectWrite font face
	sk_sp<DWriteFontTypeface> t_typeface(DWriteFontTypeface::Create(s_DWFactory, p_face, t_font, t_family));

	// Clean up the DirectWrite resources
	t_family->Release();
	t_font->Release();

	// Configurethe paint for text rendering.
	// Both LCD font smoothing and embedded bitmap rendering are enable
	x_paint.setTypeface(t_typeface);
	x_paint.setLCDRenderText(true);
	x_paint.setEmbeddedBitmapText(true);

	// Set the size, converting device independent pixels (DIPs) to points
	x_paint.setTextSize(p_emsize);

	// Set the transform we're using
	SkMatrix t_matrix;
	MCGAffineTransformToSkMatrix(p_transform, t_matrix);
	x_paint.setTextMatrix(&t_matrix);
}

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

MCGFloat __MCGContextMeasurePlatformText(MCGContextRef self, const unichar_t *p_text, uindex_t p_length, const MCGFont &p_font, const MCGAffineTransform &p_transform)
{
	// Calculated width
	FLOAT t_width = 0.0f;
	
	// Create a text format object describing the font
	IDWriteTextFormat* t_format = MCGDWTextFormatFromHFONT(static_cast<HFONT>(p_font.fid), p_font.size);
    if (t_format != nullptr)
    {
	    // Create a text layout for the string and this font
	    IDWriteTextLayout* t_layout = nil;
	    if (SUCCEEDED(s_DWFactory->CreateTextLayout(p_text, p_length / sizeof(unichar_t), t_format, INFINITY, INFINITY, &t_layout)))
	    {
		    // Get the text metrics for the layout
		    DWRITE_TEXT_METRICS t_metrics;
		    if (SUCCEEDED(t_layout->GetMetrics(&t_metrics)))
		    {
			    t_width = t_metrics.widthIncludingTrailingWhitespace;
		    }

            t_layout->Release();
	    }

	    t_format->Release();
    }

	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 text format object describing the font
	IDWriteTextFormat* t_format = MCGDWTextFormatFromHFONT(static_cast<HFONT>(p_font.fid), p_font.size);
	if (t_format == nil)
		return false;

	// Create a text layout for the string and this font
	bool t_success = false;
	IDWriteTextLayout* t_layout = nil;
	if (SUCCEEDED(s_DWFactory->CreateTextLayout(p_text, p_length / sizeof(unichar_t), t_format, INFINITY, INFINITY, &t_layout)))
	{
		// Get the text metrics for the layout
		DWRITE_LINE_METRICS t_line_metrics;
		UINT32 t_line_metrics_count = 1;

		DWRITE_TEXT_METRICS t_metrics;
		if (SUCCEEDED(t_layout->GetMetrics(&t_metrics)) && SUCCEEDED(t_layout->GetLineMetrics(&t_line_metrics, 1, &t_line_metrics_count)))
		{
			r_bounds = MCGRectangleMake(t_metrics.left, -t_line_metrics.baseline, t_metrics.width, t_metrics.height);
			t_success = true;
		}
	}

	// Release the created objects and return
	if (t_layout != NULL)
		t_layout->Release();
	if (t_format != NULL)
		t_format->Release();

	return t_success;
}

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 transform that drawing will be using
	MCGAffineTransform t_transform = MCGContextGetDeviceTransform(self);

	// Create a text format object describing the font
	IDWriteTextFormat* t_format = MCGDWTextFormatFromHFONT(static_cast<HFONT>(p_font.fid), p_font.size);
	if (t_format == nil)
		return;

	// Create a text layout for the string and this font
	bool t_success = false;
	IDWriteTextLayout* t_layout = nil;
	if (SUCCEEDED(s_DWFactory->CreateTextLayout(p_text, p_length / sizeof(unichar_t), t_format, INFINITY, INFINITY, &t_layout)))
	{
		MCGFloat t_advance = 0.0f;
		MCGFloat t_advance_direction = 1.0f;

		// If the text is RTL, the advance starts from the end and decreases
		if (p_rtl)
		{
			DWRITE_TEXT_METRICS t_metrics;
			t_layout->GetMetrics(&t_metrics);
			t_advance = t_metrics.width;
			t_advance_direction = -1.0f;
		}
		
        // Setup the paint
        SkPaint t_paint;
        if (MCGContextSetupFill(self, t_paint))
        {
            // Drawing callback
            auto t_callback = [=, &t_advance, &t_paint](FLOAT p_x, FLOAT p_y, DWRITE_MEASURING_MODE p_mode, const DWRITE_GLYPH_RUN* p_run, const DWRITE_GLYPH_RUN_DESCRIPTION* p_description)
            {
                // Apply the font face to the Skia paint object
                MCGSkPaintFromDWFontFace(p_run->fontFace, p_run->fontEmSize, t_transform, t_paint);

                // disable LCD rendering when backing layer may be transparent
                if (!MCGContextIsLayerOpaque(self))
                    t_paint.setLCDRenderText(false);

                // Force anti-aliasing on so that we get nicely-rendered text
                t_paint.setAntiAlias(true);

                // Text will be specified by glyph index, not codepoint/codeunit
                t_paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);

                // Loop over the glyphs in the run
                for (UINT32 i = 0; i < p_run->glyphCount; i++)
                {
                    if (p_rtl)
                    {
                        // Advance the position for the next glyph
                        t_advance += t_advance_direction * p_run->glyphAdvances[i];
                    }
                    
                    // Position for this glyph
                    MCGFloat t_x = p_location.x + t_advance;
                    MCGFloat t_y = p_location.y;
                    if (p_run->glyphOffsets)
                    {
                        t_x += t_advance_direction * p_run->glyphOffsets[i].advanceOffset;
                        t_y += p_run->glyphOffsets[i].ascenderOffset;
                    }

                    if (!p_rtl)
                    {
                        // Advance the position for the next glyph
                        t_advance += t_advance_direction * p_run->glyphAdvances[i];
                    }

                    // Render this glyph to the canvas
                    // Relies on DirectWrite and Skia both using 16-bit integers for glyph indices
                    self->layer->canvas->drawText(&p_run->glyphIndices[i], sizeof(SkGlyphID), t_x, t_y, t_paint);
                }
            };
            
            // Create an object to receive the "Draw" callbacks
            auto* t_renderer = new MCGDWRenderer<decltype(t_callback)>(t_callback);

            // Perform the drawing
            t_layout->Draw(self, t_renderer, 0.0f, 0.0f);

            // Free the renderer object
            t_renderer->Release();
        }
	}

	// Free the DirectWrite objects
	if (t_layout != nil)
		t_layout->Release();
	if (t_format != nil)
		t_format->Release();
}