* @param underline Whether to underline what has been drawn or not.

 * @param truncation Whether to perform string truncation or not.

 *

 * @return In case of left or center alignment the right most pixel we have drawn to.

 *         In case of right alignment the left most pixel we have drawn to.

 */

{

	/*

	 * The following is needed for truncation.

	 * Depending on the text direction, we either remove bits at the rear

	 * or the front. For this we shift the entire area to draw so it fits

	 * within the left/right bounds and the side we do not truncate it on.

		/*

		 * Assumption may be made that all fonts of a run are of the same size.

		 * In any case, we'll use these dots for the abbreviation, so even if

		 * another size would be chosen it won't have truncated too little for

		 * the truncation dots.

		 */

		GlyphID dot_glyph = fc->MapCharToGlyph('.');

		dot_width = fc->GetGlyphWidth(dot_glyph);

		dot_sprite = fc->GetGlyph(dot_glyph);

		if (_current_text_dir == TD_RTL) {

			min_x += 3 * dot_width;

		default:

			NOT_REACHED();

	}

	TextColour colour = TC_BLACK;

	bool draw_shadow = false;

		const Font *f = (const Font*)run.GetFont();

		FontCache *fc = f->fc;

		colour = f->colour;

		SetColourRemap(colour);

		return 0;

	}

	Layouter layout(str, INT32_MAX, colour, fontsize);

	if (layout.size() == 0) return 0;

}

/**

 * Draw string, possibly truncated to make it fit in its allocated space

 *

 * @param left   The left most position to draw on.

		default: NOT_REACHED();

	}

	int last_line = top;

	int first_line = bottom;

		int line_height = line->GetLeading();

		if (y >= top && y < bottom) {

			last_line = y + line_height;

			if (first_line > y) first_line = y;

		}

		y += line_height;

	}

	return ((align & SA_VERT_MASK) == SA_BOTTOM) ? first_line : last_line;

}

	return FALSE;

}

/**

 * Wrapper for doing layouts with ICU.

 */

	icu::ParagraphLayout *p; ///< The actual ICU paragraph layout.

public:

	/** Visual run contains data about the bit of text with the same font. */

	class ICUVisualRun : public ParagraphLayouter::VisualRun {

		const icu::ParagraphLayout::VisualRun *vr; ///< The actual ICU vr.

	};

	ICUParagraphLayout(icu::ParagraphLayout *p) : p(p) { }

	~ICUParagraphLayout() override { delete p; }

	void Reflow() override  { p->reflow(); }

	{

		icu::ParagraphLayout::Line *l = p->nextLine(max_width);

	}

};

/**

 * Helper class to construct a new #ICUParagraphLayout.

 */

	const WChar *buffer_begin; ///< Begin of the buffer.

	const WChar *buffer;       ///< The current location in the buffer.

	FontMap &runs;             ///< The fonts we have to use for this paragraph.

	FallbackParagraphLayout(WChar *buffer, int length, FontMap &runs);

	void Reflow() override;

};

/**

 * Helper class to construct a new #FallbackParagraphLayout.

 */

class FallbackParagraphLayoutFactory {

/**

 * Construct a new line with a maximum width.

 * @param max_width The maximum width of the string.

 * @return A Line, or NULL when at the end of the paragraph.

 */

{

	/* Simple idea:

	 *  - split a line at a newline character, or at a space where we can break a line.

	 *  - split for a visual run whenever a new line happens, or the font changes.

	 */

	if (this->buffer == NULL) return NULL;

	if (*this->buffer == '\0') {

		/* Only a newline. */

		this->buffer = NULL;

		l->emplace_back(this->runs.front().second, this->buffer, 0, 0);

	}

	int offset = this->buffer - this->buffer_begin;

	FontMap::iterator iter = this->runs.data();

	while (iter->first <= offset) {

		iter++;

				/* The string is longer than maximum width so we need to decide

				 * what to do with it. */

				if (width == char_width) {

					/* The character is wider than allowed width; don't know

					 * what to do with this case... bail out! */

					this->buffer = NULL;

				}

				if (last_space == NULL) {

					/* No space has been found. Just terminate at our current

					 * location. This usually happens for languages that do not

					 * require spaces in strings, like Chinese, Japanese and

	}

	if (l->size() == 0 || last_char - begin != 0) {

		int w = l->GetWidth();

		l->emplace_back(iter->second, begin, last_char - begin, w);

	}

}

/**

 * Helper for getting a ParagraphLayouter of the given type.

 *

 * @note In case no ParagraphLayouter could be constructed, line.layout will be NULL.

			if (line.layout == NULL) {

				GetLayouter<FallbackParagraphLayoutFactory>(line, str, state);

			}

		}

		}

	} while (c != '\0');

}

/**

 * Get the boundaries of this paragraph.

 * @return The boundaries.

 */

Dimension Layouter::GetBounds()

{

	Dimension d = { 0, 0 };

		d.width = max<uint>(d.width, l->GetWidth());

		d.height += l->GetLeading();

	}

	return d;

}

		str += len;

		index += this->front()->GetInternalCharLength(c);

	}

	if (str == ch) {

		/* Valid character. */

		/* Pointer to the end-of-string/line marker? Return total line width. */

		if (*ch == '\0' || *ch == '\n') {

			Point p = { line->GetWidth(), 0 };

			return p;

		}

 * Get the character that is at a position.

 * @param x Position in the string.

 * @return Pointer to the character at the position or NULL if no character is at the position.

 */

const char *Layouter::GetCharAtPosition(int x) const

{

	for (int run_index = 0; run_index < line->CountRuns(); run_index++) {

		const ParagraphLayouter::VisualRun &run = line->GetVisualRun(run_index);

		for (int i = 0; i < run.GetGlyphCount(); i++) {

			/* Not a valid glyph (empty). */

		virtual int CountRuns() const = 0;

		virtual const VisualRun &GetVisualRun(int run) const = 0;

		virtual int GetInternalCharLength(WChar c) const = 0;

	};

	virtual void Reflow() = 0;

};

/**

 * The layouter performs all the layout work.

 *

 * It also accounts for the memory allocations and frees.

 */

	const char *string; ///< Pointer to the original string.

	/** Key into the linecache */

	struct LineCacheKey {

		FontState state_before;  ///< Font state at the beginning of the line.

		std::string str;         ///< Source string of the line (including colour and font size codes).

	void Reflow() override

	{

		this->cur_offset = 0;

	}

};

/** Get the width of an encoded sprite font character.  */

static CGFloat SpriteFontGetWidth(void *ref_con)

{

	CTTypesetterRef typesetter = CTTypesetterCreateWithAttributedString(str);

	CFRelease(str);

	return typesetter != NULL ? new CoreTextParagraphLayout(typesetter, buff, length, fontMapping) : NULL;

}

{

	if (this->cur_offset >= this->length) return NULL;

	/* Get line break position, trying word breaking first and breaking somewhere if that doesn't work. */

	CFIndex len = CTTypesetterSuggestLineBreak(this->typesetter, this->cur_offset, max_width);

	if (len <= 0) len = CTTypesetterSuggestClusterBreak(this->typesetter, this->cur_offset, max_width);

	/* Create line. */

	CTLineRef line = CTTypesetterCreateLine(this->typesetter, CFRangeMake(this->cur_offset, len));

	this->cur_offset += len;

}

CoreTextParagraphLayout::CoreTextVisualRun::CoreTextVisualRun(CTRunRef run, Font *font, const CoreTextParagraphLayoutFactory::CharType *buff) : font(font)

{

	this->glyphs.resize(CTRunGetGlyphCount(run));

 * Get the height of the line.

 * @return The maximum height of the line.

 */

int CoreTextParagraphLayout::CoreTextLine::GetLeading() const

{

	int leading = 0;

	}

	return leading;

}

/**

 */

int CoreTextParagraphLayout::CoreTextLine::GetWidth() const

{

	if (this->size() == 0) return 0;

	int total_width = 0;

	}

	return total_width;

}

	void Reflow() override

	{

		this->cur_range = this->ranges.begin();

		this->cur_range_offset = 0;

	}

};

void UniscribeResetScriptCache(FontSize size)

{

	if (_script_cache[size] != NULL) {

		ScriptFreeCache(&_script_cache[size]);

		}

	}

	return new UniscribeParagraphLayout(ranges, buff);

}

{

	std::vector<UniscribeRun>::iterator start_run = this->cur_range;

	std::vector<UniscribeRun>::iterator last_run = this->cur_range;

	if (start_run == this->ranges.end()) return NULL;

		bidi_level.push_back(r->sa.s.uBidiLevel);

	}

	std::vector<INT> vis_to_log(bidi_level.size());

	if (FAILED(ScriptLayout((int)bidi_level.size(), &bidi_level[0], &vis_to_log[0], NULL))) return NULL;

	/* Create line. */

	int cur_pos = 0;

	for (std::vector<INT>::iterator l = vis_to_log.begin(); l != vis_to_log.end(); l++) {

		std::vector<UniscribeRun>::iterator i_run = start_run + *l;

		UniscribeRun run = *i_run;

#include <cstdio>

#include <cstddef>

#include <cstring>

#include <cstdlib>

#include <climits>

#include <cassert>

#ifndef SIZE_MAX

	#define SIZE_MAX ((size_t)-1)

#endif

#if defined(UNIX) || defined(__MINGW32__)