libui/windows/attrstr.cpp

// 12 february 2017
#include "uipriv_windows.hpp"
#include "attrstr.hpp"

// TODO this whole file needs cleanup

// yep, even when it supports C++11, it doesn't support C++11
// we require MSVC 2013; this was added in MSVC 2015 (https://msdn.microsoft.com/en-us/library/wfa0edys.aspx)
#ifdef _MSC_VER
#if _MSC_VER < 1900
#define noexcept
#endif
#endif

// we need to collect all the background parameters and add them all at once
// TODO consider having background parameters in the drawing effects
// TODO contextual alternates override ligatures?
// TODO rename this struct to something that isn't exclusively foreach-ing?
struct foreachParams {
	const uint16_t *s;
	size_t len;
	IDWriteTextLayout *layout;
	std::vector<struct drawTextBackgroundParams *> *backgroundParams;
};

static std::hash<double> doubleHash;

// we need to combine color and underline style into one unit for IDWriteLayout::SetDrawingEffect()
// we also want to combine identical effects, which DirectWrite doesn't seem to provide a way to do
// we can at least try to goad it into doing so if we can deduplicate effects once they're all computed
// so what we do is use this class to store in-progress effects, much like uiprivCombinedFontAttr on the OS X code
// we then deduplicate them later while converting them into a form suitable for drawing with; see applyEffectsAttributes() below
class combinedEffectsAttr : public IUnknown {
	ULONG refcount;
	uiAttribute *colorAttr;
	uiAttribute *underlineAttr;
	uiAttribute *underlineColorAttr;

	void setAttribute(uiAttribute *a)
	{
		if (a == NULL)
			return;
		switch (uiAttributeGetType(a)) {
		case uiAttributeTypeColor:
			if (this->colorAttr != NULL)
				uiprivAttributeRelease(this->colorAttr);
			this->colorAttr = uiprivAttributeRetain(a);
			break;
		case uiAttributeTypeUnderline:
			if (this->underlineAttr != NULL)
				uiprivAttributeRelease(this->underlineAttr);
			this->underlineAttr = uiprivAttributeRetain(a);
			break;
		case uiAttributeTypeUnderlineColor:
			if (this->underlineAttr != NULL)
				uiprivAttributeRelease(this->underlineAttr);
			this->underlineColorAttr = uiprivAttributeRetain(a);
			break;
		}
	}

	// this is needed by applyEffectsAttributes() below
	// TODO doesn't uiprivAttributeEqual() already do this; if it doesn't, make it so; if (or when) it does, fix all platforms to avoid this extra check
	static bool attrEqual(uiAttribute *a, uiAttribute *b)
	{
		if (a == NULL && b == NULL)
			return true;
		if (a == NULL || b == NULL)
			return false;
		return uiprivAttributeEqual(a, b);
	}
public:
	combinedEffectsAttr(uiAttribute *a)
	{
		this->refcount = 1;
		this->colorAttr = NULL;
		this->underlineAttr = NULL;
		this->underlineColorAttr = NULL;
		this->setAttribute(a);
	}

	~combinedEffectsAttr()
	{
		if (this->colorAttr != NULL)
			uiprivAttributeRelease(this->colorAttr);
		if (this->underlineAttr != NULL)
			uiprivAttributeRelease(this->underlineAttr);
		if (this->underlineColorAttr != NULL)
			uiprivAttributeRelease(this->underlineColorAttr);
	}

	// IUnknown
	virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
	{
		if (ppvObject == NULL)
			return E_POINTER;
		if (riid == IID_IUnknown) {
			this->AddRef();
			*ppvObject = this;
			return S_OK;
		}
		*ppvObject = NULL;
		return E_NOINTERFACE;
	}

	virtual ULONG STDMETHODCALLTYPE AddRef(void)
	{
		this->refcount++;
		return this->refcount;
	}

	virtual ULONG STDMETHODCALLTYPE Release(void)
	{
		this->refcount--;
		if (this->refcount == 0) {
			delete this;
			return 0;
		}
		return this->refcount;
	}

	combinedEffectsAttr *cloneWith(uiAttribute *a)
	{
		combinedEffectsAttr *b;

		b = new combinedEffectsAttr(this->colorAttr);
		b->setAttribute(this->underlineAttr);
		b->setAttribute(this->underlineColorAttr);
		b->setAttribute(a);
		return b;
	}

	// and these are also needed by applyEffectsAttributes() below
	size_t hash(void) const noexcept
	{
		size_t ret = 0;
		double r, g, b, a;
		uiUnderlineColor colorType;

		if (this->colorAttr != NULL) {
			uiAttributeColor(this->colorAttr, &r, &g, &b, &a);
			ret ^= doubleHash(r);
			ret ^= doubleHash(g);
			ret ^= doubleHash(b);
			ret ^= doubleHash(a);
		}
		if (this->underlineAttr != NULL)
			ret ^= (size_t) uiAttributeUnderline(this->underlineAttr);
		if (this->underlineColorAttr != NULL) {
			uiAttributeUnderlineColor(this->underlineColorAttr, &colorType, &r, &g, &b, &a);
			ret ^= (size_t) colorType;
			ret ^= doubleHash(r);
			ret ^= doubleHash(g);
			ret ^= doubleHash(b);
			ret ^= doubleHash(a);
		}
		return ret;
	}

	bool equals(const combinedEffectsAttr *b) const
	{
		if (b == NULL)
			return false;
		return combinedEffectsAttr::attrEqual(this->colorAttr, b->colorAttr) &&
			combinedEffectsAttr::attrEqual(this->underlineAttr, b->underlineAttr) &&
			combinedEffectsAttr::attrEqual(this->underlineColorAttr, b->underlineColorAttr);
	}

	drawingEffectsAttr *toDrawingEffectsAttr(void)
	{
		drawingEffectsAttr *dea;
		double r, g, b, a;
		uiUnderlineColor colorType;

		dea = new drawingEffectsAttr;
		if (this->colorAttr != NULL) {
			uiAttributeColor(this->colorAttr, &r, &g, &b, &a);
			dea->setColor(r, g, b, a);
		}
		if (this->underlineAttr != NULL)
			dea->setUnderline(uiAttributeUnderline(this->underlineAttr));
		if (this->underlineColorAttr != NULL) {
			uiAttributeUnderlineColor(this->underlineColorAttr, &colorType, &r, &g, &b, &a);
			// TODO see if Microsoft has any standard colors for these
			switch (colorType) {
			case uiUnderlineColorSpelling:
				// TODO consider using the GtkTextView style property error-underline-color here if Microsoft has no preference
				r = 1.0;
				g = 0.0;
				b = 0.0;
				a = 1.0;
				break;
			case uiUnderlineColorGrammar:
				r = 0.0;
				g = 1.0;
				b = 0.0;
				a = 1.0;
				break;
			case uiUnderlineColorAuxiliary:
				r = 0.0;
				g = 0.0;
				b = 1.0;
				a = 1.0;
				break;
			}
			dea->setUnderlineColor(r, g, b, a);
		}
		return dea;
	}
};

// also needed by applyEffectsAttributes() below
// TODO provide all the fields of std::hash and std::equal_to?
class applyEffectsHash {
public:
	typedef combinedEffectsAttr *ceaptr;
	size_t operator()(applyEffectsHash::ceaptr const &cea) const noexcept
	{
		return cea->hash();
	}
};

class applyEffectsEqualTo {
public:
	typedef combinedEffectsAttr *ceaptr;
	bool operator()(const applyEffectsEqualTo::ceaptr &a, const applyEffectsEqualTo::ceaptr &b) const
	{
		return a->equals(b);
	}
};

static HRESULT addEffectAttributeToRange(struct foreachParams *p, size_t start, size_t end, uiAttribute *attr)
{
	IUnknown *u;
	combinedEffectsAttr *cea;
	DWRITE_TEXT_RANGE range;
	size_t diff;
	HRESULT hr;

	while (start < end) {
		hr = p->layout->GetDrawingEffect(start, &u, &range);
		if (hr != S_OK)
			return hr;
		cea = (combinedEffectsAttr *) u;
		if (cea == NULL)
			cea = new combinedEffectsAttr(attr);
		else
			cea = cea->cloneWith(attr);
		// clamp range within [start, end)
		if (range.startPosition < start) {
			diff = start - range.startPosition;
			range.startPosition = start;
			range.length -= diff;
		}
		if ((range.startPosition + range.length) > end)
			range.length = end - range.startPosition;
		hr = p->layout->SetDrawingEffect(cea, range);
		// SetDrawingEffect will AddRef(), so Release() our copy
		// (and we're abandoning early if that failed, so this will make sure things are cleaned up in that case)
		cea->Release();
		if (hr != S_OK)
			return hr;
		start += range.length;
	}
	return S_OK;
}

static void addBackgroundParams(struct foreachParams *p, size_t start, size_t end, const uiAttribute *attr)
{
	struct drawTextBackgroundParams *params;

	params = uiprivNew(struct drawTextBackgroundParams);
	params->start = start;
	params->end = end;
	uiAttributeColor(attr, &(params->r), &(params->g), &(params->b), &(params->a));
	p->backgroundParams->push_back(params);
}

static uiForEach processAttribute(const uiAttributedString *s, const uiAttribute *attr, size_t start, size_t end, void *data)
{
	struct foreachParams *p = (struct foreachParams *) data;
	DWRITE_TEXT_RANGE range;
	WCHAR *wfamily;
	BOOL hasUnderline;
	IDWriteTypography *dt;
	HRESULT hr;

	start = uiprivAttributedStringUTF8ToUTF16(s, start);
	end = uiprivAttributedStringUTF8ToUTF16(s, end);
	range.startPosition = start;
	range.length = end - start;
	switch (uiAttributeGetType(attr)) {
	case uiAttributeTypeFamily:
		wfamily = toUTF16(uiAttributeFamily(attr));
		hr = p->layout->SetFontFamilyName(wfamily, range);
		if (hr != S_OK)
			logHRESULT(L"error applying family name attribute", hr);
		uiprivFree(wfamily);
		break;
	case uiAttributeTypeSize:
		hr = p->layout->SetFontSize(
// TODO unify with fontmatch.cpp and/or attrstr.hpp
#define pointSizeToDWriteSize(size) (size * (96.0 / 72.0))
			pointSizeToDWriteSize(uiAttributeSize(attr)),
			range);
		if (hr != S_OK)
			logHRESULT(L"error applying size attribute", hr);
		break;
	case uiAttributeTypeWeight:
		hr = p->layout->SetFontWeight(
			uiprivWeightToDWriteWeight(uiAttributeWeight(attr)),
			range);
		if (hr != S_OK)
			logHRESULT(L"error applying weight attribute", hr);
		break;
	case uiAttributeTypeItalic:
		hr = p->layout->SetFontStyle(
			uiprivItalicToDWriteStyle(uiAttributeItalic(attr)),
			range);
		if (hr != S_OK)
			logHRESULT(L"error applying italic attribute", hr);
		break;
	case uiAttributeTypeStretch:
		hr = p->layout->SetFontStretch(
			uiprivStretchToDWriteStretch(uiAttributeStretch(attr)),
			range);
		if (hr != S_OK)
			logHRESULT(L"error applying stretch attribute", hr);
		break;
	case uiAttributeTypeUnderline:
		// mark that we have an underline; otherwise, DirectWrite will never call our custom renderer's DrawUnderline() method
		hasUnderline = FALSE;
		if (uiAttributeUnderline(attr) != uiUnderlineNone)
			hasUnderline = TRUE;
		hr = p->layout->SetUnderline(hasUnderline, range);
		if (hr != S_OK)
			logHRESULT(L"error applying underline attribute", hr);
		// and fall through to set the underline style through the drawing effect
	case uiAttributeTypeColor:
	case uiAttributeTypeUnderlineColor:
		// TODO const-correct this properly
		hr = addEffectAttributeToRange(p, start, end, (uiAttribute *) attr);
		if (hr != S_OK)
			logHRESULT(L"error applying effect (color, underline, or underline color) attribute", hr);
		break;
	case uiAttributeTypeBackground:
		addBackgroundParams(p, start, end, attr);
		break;
	case uiAttributeTypeFeatures:
		// only generate an attribute if not NULL
		// TODO do we still need to do this or not...
		if (uiAttributeFeatures(attr) == NULL)
			break;
		dt = uiprivOpenTypeFeaturesToIDWriteTypography(uiAttributeFeatures(attr));
		hr = p->layout->SetTypography(dt, range);
		if (hr != S_OK)
			logHRESULT(L"error applying features attribute", hr);
		dt->Release();
		break;
	}
	return uiForEachContinue;
}

static HRESULT applyEffectsAttributes(struct foreachParams *p)
{
	IUnknown *u;
	combinedEffectsAttr *cea;
	drawingEffectsAttr *dea;
	DWRITE_TEXT_RANGE range;
	// here's the magic: this std::unordered_map will deduplicate all of our combinedEffectsAttrs, mapping all identical ones to a single drawingEffectsAttr
	// because drawingEffectsAttr is the *actual* drawing effect we want for rendering, we also replace the combinedEffectsAttrs with them in the IDWriteTextLayout at the same time
	// note the use of our custom hash and equal_to implementations
	std::unordered_map<combinedEffectsAttr *, drawingEffectsAttr *,
		applyEffectsHash, applyEffectsEqualTo> effects;
	HRESULT hr;

	// go through, replacing every combinedEffectsAttr with the proper drawingEffectsAttr
	range.startPosition = 0;
	// and in case this while loop never runs, make hr valid to start with
	hr = S_OK;
	while (range.startPosition < p->len) {
		hr = p->layout->GetDrawingEffect(range.startPosition, &u, &range);
		if (hr != S_OK)
			// note that we are breaking instead of returning; this allows us to clean up on failure
			break;
		cea = (combinedEffectsAttr *) u;
		if (cea != NULL) {
			auto diter = effects.find(cea);
			if (diter != effects.end())
				dea = diter->second;
			else {
				dea = cea->toDrawingEffectsAttr();
				effects.insert({cea, dea});
			}
			hr = p->layout->SetDrawingEffect(dea, range);
			// don't release dea; we need the reference that's inside the map
			// (we don't take extra references on lookup, so this will be fine)
			if (hr != S_OK)
				break;
		}
		range.startPosition += range.length;
	}

	// and clean up, finally destroying the combinedEffectAttrs too
	// we do this in the case of failure as well, to make sure everything is properly cleaned up
	for (auto iter = effects.begin(); iter != effects.end(); iter++) {
		iter->first->Release();
		iter->second->Release();
	}
	return hr;
}

void uiprivAttributedStringApplyAttributesToDWriteTextLayout(uiDrawTextLayoutParams *p, IDWriteTextLayout *layout, std::vector<struct drawTextBackgroundParams *> **backgroundParams)
{
	struct foreachParams fep;
	HRESULT hr;

	fep.s = uiprivAttributedStringUTF16String(p->String);
	fep.len = uiprivAttributedStringUTF16Len(p->String);
	fep.layout = layout;
	fep.backgroundParams = new std::vector<struct drawTextBackgroundParams *>;
	uiAttributedStringForEachAttribute(p->String, processAttribute, &fep);
	hr = applyEffectsAttributes(&fep);
	if (hr != S_OK)
		logHRESULT(L"error applying effects attributes", hr);
	*backgroundParams = fep.backgroundParams;
}