* @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.

 */

{

	if (line->countRuns() == 0) return 0;

	}

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

		const Font *f = (const Font*)run->getFont();

		FontCache *fc = f->fc;

	int last_line = top;

	int first_line = bottom;

		int line_height = line->getLeading();

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

 * @param char_count The number of characters in this run.

 * @param x          The initial x position for this run.

 */

		font(font), glyph_count(char_count)

{

	this->glyphs = MallocT<GlyphID>(this->glyph_count);

}

/** Free all data. */

{

	free(this->positions);

	free(this->glyph_to_char);

 * Get the font associated with this run.

 * @return The font.

 */

{

	return this->font;

}

 * Get the number of glyphs in this run.

 * @return The number of glyphs.

 */

{

	return this->glyph_count;

}

 * Get the glyphs of this run.

 * @return The glyphs.

 */

{

	return this->glyphs;

}

 * Get the positions of this run.

 * @return The positions.

 */

{

	return this->positions;

}

 * Get the glyph-to-character map for this visual run.

 * @return The glyph-to-character map.

 */

{

	return this->glyph_to_char;

}

 * Get the height of this font.

 * @return The height of the font.

 */

{

	return this->getFont()->fc->GetHeight();

}

 * Get the height of the line.

 * @return The maximum height of the line.

 */

{

	int leading = 0;

		leading = max(leading, (*run)->getLeading());

	}

 * Get the width of this line.

 * @return The width of the line.

 */

{

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

	 * Since there is no left-to-right support, taking this value of

	 * the last run gives us the end of the line and thus the width.

	 */

	return (int)run->getPositions()[run->getGlyphCount() * 2];

}

 * Get the number of runs in this line.

 * @return The number of runs.

 */

{

	return this->Length();

}

 * Get a specific visual run.

 * @return The visual run.

 */

{

	return *this->Get(run);

}

 * @param length The length of the paragraph.

 * @param runs   The font mapping of this paragraph.

 */

{

	assert(runs.End()[-1].first == length);

}

/**

 * Reset the position to the start of the paragraph.

 */

{

	this->buffer = this->buffer_begin;

}

 * @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.

	 */

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

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

		/* Only a newline. */

		this->buffer = NULL;

		return l;

	}

		if (this->buffer == next_run) {

			int w = l->getWidth();

			iter++;

			assert(iter != this->runs.End());

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

		int w = l->getWidth();

	}

	return l;

}

 * @param fontMapping THe mapping of the fonts.

 * @return The ParagraphLayout instance.

 */

{

}

#endif /* !WITH_ICU */

		}

		/* Copy all lines into a local cache so we can reuse them later on more easily. */

		while ((l = line.layout->nextLine(maxw)) != NULL) {

			*this->Append() = l;

		}

Dimension Layouter::GetBounds()

{

	Dimension d = { 0, 0 };

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

		d.height += (*l)->getLeading();

	}

	if (str == ch) {

		/* Valid character. */

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

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

		/* Scan all runs until we've found our code point index. */

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

			for (int i = 0; i < run->getGlyphCount(); i++) {

				/* Matching glyph? Return position. */

 */

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

{

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

		for (int i = 0; i < run->getGlyphCount(); i++) {

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

#define ICU_FONTINSTANCE : public LEFontInstance

#else /* WITH_ICU */

#define ICU_FONTINSTANCE

#endif /* WITH_ICU */

/**

 * Text drawing parameters, which can change while drawing a line, but are kept between multiple parts

 * @note Does not conform to function naming style as it provides a

 *       fallback for the ICU class.

 */

public:

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

		Font *font;       ///< The font used to layout these.

		GlyphID *glyphs;  ///< The glyphs we're drawing.

		float *positions; ///< The positions of the glyphs.

		int glyph_count;  ///< The number of glyphs.

	public:

		const Font *getFont() const;

		int getGlyphCount() const;

		const GlyphID *getGlyphs() const;

	};

	/** A single line worth of VisualRuns. */

	public:

		int getLeading() const;

		int getWidth() const;

		int countRuns() const;

	};

	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.

	void reflow();

	const Line *nextLine(int max_width);

};

 *

 * It also accounts for the memory allocations and frees.

 */

#ifdef WITH_ICU

	typedef UChar CharType; ///< The type of character used within the layouter.

#else /* WITH_ICU */

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

	size_t AppendToBuffer(CharType *buff, const CharType *buffer_last, WChar c);

	/** Key into the linecache */

	struct LineCacheKey {

		CharType buffer[DRAW_STRING_BUFFER]; ///< Accessed by both ICU's and our ParagraphLayout::nextLine.

		FontMap runs;                        ///< Accessed by our ParagraphLayout::nextLine.

		LineCacheItem() : layout(NULL) {}

		~LineCacheItem() { delete layout; }