#include <ft2build.h></ft2build.h>

#include FT_FREETYPE_H

#include "private.h"

#include "font.h"

#include "drawing.h"

#define FONT_MAP_GLYPHSIZE      64

#define FONT_MAP_BORDERSIZE     16

#define FONT_MAP_CNT            16

#define FONT_MAP_GLYPHWORKSIZE  (FONT_MAP_GLYPHSIZE - FONT_MAP_BORDERSIZE)

#define FONT_MAP_FULLCNT        (FONT_MAP_CNT*FONT_MAP_CNT)

#define FONT_MAP_TEXSIZE        (FONT_MAP_CNT*FONT_MAP_GLYPHSIZE)

#define FONT_MAX_GLYPHS         (256*256)

#define FONT_BASE_SIZE          72

#define FONT_BADCHAR_CODE       0xFFFD

typedef struct _HeliFontMap HeliFontMap;

typedef struct _HeliFontInstance HeliFontInstance;

typedef struct _HeliCharDesc HeliCharDesc;

typedef struct _HeliGlyph {

	HeliFontMap *map;

	HeliFontInstance *fi;

	int code;

	int index;

	double l, t, r, b;

	double advance;

} HeliGlyph;

struct _HeliFontMap {

	HeliFontMap *prev, *next;

	unsigned int texid;

	int count;

	HeliGlyph glyphs[FONT_MAP_FULLCNT];

};

struct _HeliFontInstance {

	char *path;

	FT_Face face;

	double height;

	double xheight;

	double ascender;

	double descender;

	HeliGlyph *glyphs[FONT_MAX_GLYPHS];

	int refcount;

};

struct _HeliCharDesc {

	HeliGlyph *glyph;

	int charpos;

	double pos;

	double x, y;

	HeliCharDesc *next;

};

typedef struct _HeliLineDesc {

	int begin, end;

	double x, y;

	double l, t, r, b;

	double xheight;

	double ascender;

	double descender;

	double height;

	double width;

} HeliLineDesc;

struct _TextLayout {

	Font font;

	int linesCount;

	HeliLineDesc *lines;

	HeliCharDesc *chars;

	double l, t, r, b;

	double ll, lt, lr, lb;

};

struct _Font {

	HeliFontInstance *instance;

};

static int ftInitialized = 0;

static FT_Library ftLibrary = NULL;

static HeliArray fontCache;

static HeliFontMap *fontMapFirst, *fontMapLast;

static HeliGlyph blankGlyph;

static const char blankPath[] = "";

static Font defaultFont = NULL;

static Font unicodeFont = NULL;

static int memFontIndex = 0;

static HeliFontMap* createFontMap() {

	HeliFontMap *map = calloc(1, sizeof(*map));

	map->prev = fontMapLast;

	*(fontMapLast ? &fontMapLast->next : &fontMapFirst) = map;

	fontMapLast = map;

	for(int i = 0; i < FONT_MAP_FULLCNT; ++i)

		map->glyphs[i].map = map;

	unsigned int prevtex = 0;

	glGetIntegerv(GL_TEXTURE_BINDING_2D, (int*)&prevtex);

	glGenTextures(1, &map->texid);

	glBindTexture(GL_TEXTURE_2D, map->texid);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -0.7f);

	unsigned char *buffer = (unsigned char*)calloc(1, FONT_MAP_TEXSIZE*FONT_MAP_TEXSIZE);

	for(int level = 0, size = FONT_MAP_TEXSIZE; size > 0; ++level, size >>= 1)

		glTexImage2D(GL_TEXTURE_2D, level, GL_ALPHA, size, size, 0, GL_ALPHA, GL_UNSIGNED_BYTE, buffer);

	free(buffer);

	int maxLevel = 0;

	for(int border = FONT_MAP_BORDERSIZE; border > 0; border >>= 1) ++maxLevel;

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, maxLevel - 1);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, maxLevel - 1);

	glBindTexture(GL_TEXTURE_2D, prevtex);

	return map;

}

static void destroyFontMap(HeliFontMap *map) {

	assert(!map->count);

	glDeleteTextures(1, &map->texid);

	*(map->prev ? &map->prev->next : &fontMapFirst) = map->next;

	*(map->next ? &map->next->prev : &fontMapLast ) = map->prev;

	free(map);

}

static HeliGlyph* loadGlyph(HeliFontInstance *fi, int code) {

	int index = FT_Get_Char_Index(fi->face, (unsigned int)code);

	if (!index) return &blankGlyph;

	if (FT_Load_Glyph(fi->face, index, FT_LOAD_NO_HINTING))

		return &blankGlyph;

	HeliFontMap *map;

	for(map = fontMapFirst; map; map = map->next)

		if (map->count < FONT_MAP_FULLCNT) break;

	if (!map) map = createFontMap();

	HeliGlyph *g = NULL;

	for(int i = 0; i < FONT_MAP_FULLCNT; ++i)

		if (!map->glyphs[i].fi) { g = &map->glyphs[i]; break; }

	assert(g);

	const double ftkf = 1/64.0;

	const FT_Glyph_Metrics *metrics = &fi->face->glyph->metrics;

	g->l = metrics->horiBearingX*ftkf;

	g->r = (metrics->horiBearingX + metrics->width)*ftkf;

	g->t = -metrics->horiBearingY*ftkf;

	g->b = (-metrics->horiBearingY + metrics->height)*ftkf;

	g->advance = metrics->horiAdvance*ftkf;

	unsigned char buffer[FONT_MAP_GLYPHSIZE*FONT_MAP_GLYPHSIZE] = {};

	if (metrics->width > 0 && metrics->height > 0) {

		FT_Pos size = metrics->width > metrics->height ? metrics->width : metrics->height;

		FT_Matrix matrix = {};

		matrix.xx = (FONT_MAP_GLYPHWORKSIZE-2)*64*65536/size;

		matrix.yy = (FONT_MAP_GLYPHWORKSIZE-2)*64*65536/size;

		FT_Vector offset = {};

		offset.x = 64 - metrics->horiBearingX;

		offset.y = -(64 + metrics->horiBearingY - metrics->height);

		FT_Set_Transform(fi->face, &matrix, &offset);

		int success = !FT_Load_Glyph(fi->face, index, FT_LOAD_NO_HINTING)

		           && !FT_Render_Glyph(fi->face->glyph, FT_RENDER_MODE_NORMAL);

		FT_Set_Transform(fi->face, NULL, NULL);

		if (!success) return &blankGlyph;

		const FT_Bitmap *bitmap = &fi->face->glyph->bitmap;

		int dr = 0;//fi->face->glyph->bitmap_top + 1 - FONT_MAP_GLYPHWORKSIZE;

		int dc = 0;//-fi->face->glyph->bitmap_left;

		int r0 = -dr;

		int r1 = r0 + bitmap->rows;

		int c0 = -dc;

		int c1 = c0 + bitmap->width;

		if (r0 < 0) r0 = 0;

		if (c0 < 0) c0 = 0;

		if (r1 > FONT_MAP_GLYPHWORKSIZE) r1 = FONT_MAP_GLYPHWORKSIZE;

		if (c1 > FONT_MAP_GLYPHWORKSIZE) c1 = FONT_MAP_GLYPHWORKSIZE;

		for(int r = r0; r < r1; ++r)

			for(int c = c0; c < c1; ++c)

				buffer[r*FONT_MAP_GLYPHSIZE + c] = *(bitmap->buffer + bitmap->pitch*(r + dr) + c + dc);

	}

	unsigned int prevtex = 0;

	glGetIntegerv(GL_TEXTURE_BINDING_2D, (int*)&prevtex);

	glBindTexture(GL_TEXTURE_2D, g->map->texid);

	int gi = g - g->map->glyphs;

	int r = gi/FONT_MAP_CNT;

	int c = gi%FONT_MAP_CNT;

	int size = FONT_MAP_GLYPHSIZE;

	for(int level = 0, border = FONT_MAP_BORDERSIZE; border > 0; border >>= 1, ++level) {

		glTexSubImage2D(

			GL_TEXTURE_2D,

			level,

			c*size,

			r*size,

			size,

			size,

			GL_ALPHA,

			GL_UNSIGNED_BYTE,

			buffer );

		if (border > 1) {

			size >>= 1;

			for(int r = 0; r < size; ++r)

				for(int c = 0; c < size; ++c)

					buffer[r*size + c] = (unsigned char)((

					    (unsigned int)buffer[((r*2 + 0)*size + c)*2 + 0]

					  + (unsigned int)buffer[((r*2 + 0)*size + c)*2 + 1]

					  + (unsigned int)buffer[((r*2 + 1)*size + c)*2 + 0]

					  + (unsigned int)buffer[((r*2 + 1)*size + c)*2 + 1] + 2) >> 2 );

		}

	}

	glBindTexture(GL_TEXTURE_2D, prevtex);

	g->fi = fi;

	g->code = code;

	g->index = index;

	++g->map->count;

	return g;

}

static void unloadGlyph(HeliGlyph *g) {

	g->fi = NULL;

	g->code = 0;

	g->index = 0;

	if (g->map && --g->map->count <= 0) 

		destroyFontMap(g->map);

}

static HeliFontInstance* loadFont(const char *path) {

	HeliFontInstance *fi = calloc(1, sizeof(*fi));

	fi->path = heliStringCopy(path);

	if (!ftInitialized) {

		if (FT_Init_FreeType(&ftLibrary))

			fprintf(stderr, "helianthus: cannot initialize FreeType library\n");

		ftInitialized = TRUE;

	}

	if (ftLibrary) {

		if (strncmp(path, "helimem:", 8) == 0) {

			void *data = NULL;

			int size = 0;

			fi->face = NULL;

			if (sscanf(path, "helimem:%p:%d:", &data, &size) != EOF && data && size > 0) {

				FT_Open_Args args = {};

				args.flags = FT_OPEN_MEMORY;

				args.memory_base = (FT_Byte*)data;

				args.memory_size = (FT_Long)size;

				if (FT_Open_Face(ftLibrary, &args, 0, &fi->face))

					fi->face = NULL;

			}

			if (!fi->face)

				fprintf(stderr, "helianthus: cannot load font from memory\n");

		} else {

			if (FT_New_Face(ftLibrary, path, 0, &fi->face)) {

				fprintf(stderr, "helianthus: cannot load font from file: %s\n", path);

				fi->face = NULL;

			}

		}

		if (fi->face) {

			FT_Set_Char_Size(fi->face, 0, FONT_BASE_SIZE*64, 72, 72);

			fi->height = fi->face->size->metrics.height/64.0;

			double ascender = fi->face->size->metrics.ascender/64.0;

			unsigned int xchars[] = { 'x', 'z', 'v' };

			int count = 0;

			double xheight = 0;

			for(int i = 0; i < (int)(sizeof(xchars)/sizeof(*xchars)); ++i) {

				int index = FT_Get_Char_Index(fi->face, xchars[i]);

				if (!index) continue;

				if (FT_Load_Glyph(fi->face, index, FT_LOAD_NO_HINTING))

					continue;

				xheight += fi->face->glyph->metrics.horiBearingY/64.0;

				++count;

			}

			if (count > 0) xheight /= count;

			if (xheight <= HELI_PRECISION || xheight > ascender)

				xheight = ascender;

			fi->ascender = ascender;

			fi->xheight = xheight;

			fi->descender = fi->face->size->metrics.descender/64.0;

		}

	}

	return fi;

}

static void unloadFont(HeliFontInstance *fi) {

	assert(!fi->refcount);

	for(int i = 0; i < FONT_MAX_GLYPHS; ++i)

		if (fi->glyphs[i]) unloadGlyph(fi->glyphs[i]);

	free(fi->path);

	if (fi->face) FT_Done_Face(fi->face);

	free(fi);

}

static HeliGlyph* getGlyph(HeliFontInstance *fi, int code) {

	if (code < 0 || code >= FONT_MAX_GLYPHS) return &blankGlyph;

	if (!fi->glyphs[code]) fi->glyphs[code] = loadGlyph(fi, code);

	return fi->glyphs[code];

}

Font createFont(const char *path) {

	if (!heliInitialized) return NULL;

	if (!path) path = blankPath;

	Font f = calloc(1, sizeof(*f));

	HeliPair *item = heliStringmapGet(&fontCache, path);

	if (!item) item = heliStringmapAdd(&fontCache, path, loadFont(path), (HeliFreeCallback)&unloadFont);

	f->instance = (HeliFontInstance*)item->value;

	++f->instance->refcount;

	heliObjectRegister(f, (HeliFreeCallback)&fontDestroy);

	return f;

}

Font createFontFromMemory(const void *data, int size) {

	char buffer[1024] = {};

	sprintf(buffer, "helimem:%p:%d:%d", data, size, ++memFontIndex);

	return createFont(buffer);

}

Font fontClone(Font font) {

	if (!font) return NULL;

	return createFont(font->instance ? font->instance->path : NULL);

}

void fontDestroy(Font f) {

	heliObjectUnregister(f);

	HeliDrawingState *ss = heliDrawingGetState();

	for(HeliDrawingState *s = heliDrawingGetStateStack(); s <= ss; ++s)

		{ if (ss->font == f) ss->font = NULL; }

	--f->instance->refcount;

	if (f->instance->refcount <= 0)

		heliStringmapRemove(&fontCache, f->instance->path);

	free(f);

}

void textAlign(HAlign hor, VAlign vert) {

	HeliDrawingState *s = heliDrawingGetState();

	s->horAlign = hor;

	s->vertAlign = vert;

}

void textFontDefault()

	{ heliDrawingGetState()->font = NULL; }

void textFont(Font f)

	{ heliDrawingGetState()->font = f; }

void textSize(double size)

	{ heliDrawingGetState()->fontSize = size; }

static void expand(double *min, double *max, double x) {

	if (*min > x) *min = x;

	if (*max < x) *max = x;

}

TextLayout createTextLayoutEx(const char *text, int length) {

	TextLayout layout = calloc(1, sizeof(*layout));

	int len = 0;

	while(len < length && text[len]) ++len;

	if (!text || !len) return layout;

	HeliDrawingState *drawingState = heliDrawingGetState();

	if (!defaultFont && heliBlobDefaultFontSize)

		defaultFont = createFontFromMemory(heliBlobDefaultFont, heliBlobDefaultFontSize);

	if (!unicodeFont && heliBlobUnicodeFontSize)

		unicodeFont = createFontFromMemory(heliBlobUnicodeFont, heliBlobUnicodeFontSize);

	HeliFontInstance *fonts[10];

	int fontsCount = 0;

	if ( drawingState->font

	  && drawingState->font->instance

	  && drawingState->font->instance->face )

		fonts[fontsCount++] = drawingState->font->instance;

	if ( defaultFont

	  && defaultFont->instance

	  && defaultFont->instance->face )

		fonts[fontsCount++] = defaultFont->instance;

	if ( unicodeFont

	  && unicodeFont->instance

	  && unicodeFont->instance->face )

		fonts[fontsCount++] = unicodeFont->instance;

	if (!fontsCount)

		return layout;

	int linesAllocated = 256;

	layout->linesCount = 1;

	layout->lines = calloc(linesAllocated, sizeof(HeliLineDesc));

	HeliLineDesc *line = layout->lines;

	line->height = fonts[0]->height;

	line->xheight = fonts[0]->xheight;

	line->ascender = fonts[0]->ascender;

	line->descender = fonts[0]->descender;

	layout->chars = calloc(len + 1, sizeof(HeliCharDesc));

	if ( drawingState->font

	  && drawingState->font != defaultFont

	  && drawingState->font != unicodeFont

	  && drawingState->font->instance == fonts[0] )

		layout->font = fontClone(drawingState->font);

	// gather glyphs

	const char *c = text, *e = c + len, *e1 = e - 1, *e2 = e - 2;

	while(1) {

		int code = FONT_BADCHAR_CODE;

		while(c < e && (*c & 0xC0) == 0x80) ++c;

		const char *charpos = c;

		if (c < e) {

			if ((*c & 0x80) == 0x00) {

				code = *c;

			} else

			if ((*c & 0xE0) == 0xC0) {

				if (c < e1 && (c[1] & 0xC0) == 0x80) {

					code = ((c[0] & 0x1F) << 6) | (c[1] & 0x3F);

					c += 1;

				}

			} else

			if ((*c & 0xF0) == 0xE0) {

				if (c < e2 && (c[1] & 0xC0) == 0x80 && (c[2] & 0xC0) == 0x80) {

					code = ((c[0] & 0x0F) << 12) | ((c[1] & 0x3F) << 6) | (c[2] & 0x3F);

					c += 2;

				}

			}

			++c;

		} else {

			code = 0;

		}

		HeliGlyph *glyph = &blankGlyph;

		int special = code == 0 || code == 10 || code == 13;

		int code2 = special ? 32 : code;

		for(int i = 0; i < fontsCount && !glyph->fi; ++i)

			glyph = getGlyph(fonts[i], code2);

		for(int i = 0; i < fontsCount && !glyph->fi; ++i)

			glyph = getGlyph(fonts[i], FONT_BADCHAR_CODE);

		if (!glyph->fi) continue;

		HeliCharDesc *cc = &layout->chars[line->end++];

		cc->charpos = charpos - text;

		cc->glyph = glyph;

		if (line->height    < glyph->fi->height   ) line->height    = glyph->fi->height;

		if (line->xheight   < glyph->fi->xheight  ) line->xheight   = glyph->fi->xheight;

		if (line->ascender  < glyph->fi->ascender ) line->ascender  = glyph->fi->ascender;

		if (line->descender < glyph->fi->descender) line->descender = glyph->fi->descender;

		if (line->begin < line->end - 1) {

			HeliCharDesc *cp = cc - 1;

			cc->pos = cp->pos + cp->glyph->advance;

			FT_Vector kerning = {};

			if ( cp->glyph->fi == cc->glyph->fi 

			  && !FT_Get_Kerning(

					cc->glyph->fi->face,

					cp->glyph->index,

					cc->glyph->index,

					FT_KERNING_UNFITTED,

					&kerning ))

				cc->pos += kerning.x/64.0;

			if (line->width < cc->pos + cc->glyph->advance)

				line->width = cc->pos + cc->glyph->advance;

		}

		if (!special && cc->glyph->l + HELI_PRECISION < cc->glyph->r) {

			// expand line for the visible glyph

			expand(&line->l, &line->r, cc->pos + cc->glyph->l);

			expand(&line->l, &line->r, cc->pos + cc->glyph->r);

		} else

		if (!special && isspace(code)) {

			// expand line for the space char

			expand(&line->l, &line->r, cc->pos + cc->glyph->advance);

		} else

		if (line->begin >= line->end - 1) {

			// is glyph is not space and not visible then expand line only for the first char in the line

			expand(&line->l, &line->r, cc->pos);

		}

		expand(&line->t, &line->b, cc->glyph->t);

		expand(&line->t, &line->b, cc->glyph->b);

		expand(&line->t, &line->b, -glyph->fi->height);

		if (code == 10 || code == 13) {

			if ((code == 10 && *c == 13) || (code == 13 && *c == 10)) ++c;

			if (layout->linesCount >= linesAllocated) {

				linesAllocated += linesAllocated/4;

				layout->lines = realloc(layout->lines, linesAllocated*sizeof(HeliLineDesc));

				memset(layout->lines + layout->linesCount, 0, (linesAllocated - layout->linesCount)*sizeof(HeliLineDesc));

				line = &layout->lines[layout->linesCount - 1];

			}

			++line;

			++layout->linesCount;

			line->begin = line->end = (line - 1)->end;

			line->height = fonts[0]->height;

			line->xheight = fonts[0]->xheight;

			line->ascender = fonts[0]->ascender;

			line->descender = fonts[0]->descender;

		}

		if (code == 0) break;

	}

	int charsCount = layout->lines[layout->linesCount-1].end;

	if (charsCount <= 0) return layout;

	// bounds

	double lineHeight = layout->lines->height;

	if (drawingState->vertAlign == VALIGN_CENTER)

		lineHeight = layout->lines->xheight;

	double l = 0;

	double t = -layout->lines->height;

	double r = 0;

	double b = 0;

	double ll = 0;

	double lt = -lineHeight;

	double lr = 0;

	double lb = 0;

	for(int i = 0; i < layout->linesCount; ++i) {

		HeliLineDesc *line = layout->lines + i;

		if (i > 0) line->y = (line-1)->y + line->height;

		if (l > line->l) l = line->l;

		if (r < line->r) r = line->r;

		if (t > line->t + line->y) t = line->t + line->y;

		if (b < line->b + line->y) b = line->b + line->y;

		if (lr < line->r) lr = line->r;

		if (lt > line->y - lineHeight) lt = line->y - lineHeight;

		if (lb < line->y) lb = line->y;

	}

	// alignment

	double dx = drawingState->horAlign  == HALIGN_RIGHT  ? -lr

	          : drawingState->horAlign  == HALIGN_CENTER ? -0.5*(ll + lr)

	          :                                            -ll;

	double dy = drawingState->vertAlign == VALIGN_BOTTOM ? -lb

	          : drawingState->vertAlign == VALIGN_CENTER ? -0.5*(lt + lb)

	          :                                            -lt;

	for(int i = 0; i < layout->linesCount; ++i) {

		HeliLineDesc *line = layout->lines + i;

		line->x = drawingState->horAlign == HALIGN_RIGHT  ? -line->r

		        : drawingState->horAlign == HALIGN_CENTER ? -0.5*line->r

		        :                                           0;

		line->y += dy;

		for(int j = line->begin; j < line->end; ++j) {

			HeliCharDesc *cc = layout->chars + j;

			cc->x = cc->pos + line->x;

			cc->y = line->y;

		}

	}

	// bounds

	layout->l = l + dx;

	layout->t = t + dy;

	layout->r = r + dx;

	layout->b = b + dy;

	layout->ll = ll + dx;

	layout->lt = lt + dy;

	layout->lr = lr + dx;

	layout->lb = lb + dy;

	// sort by textures	

	for(int i = 0; i < charsCount-1; ++i)

		layout->chars[i].next = &layout->chars[i+1];

	HeliCharDesc *first = NULL, *last = NULL, *current = layout->chars;

	while(current) {

		if (!current->next) {

			current = current->next = first;

		} else

		if (current->glyph->map != current->next->glyph->map) {

			*(last ? &last->next : &first) = current->next;

			last = current->next;

			current->next = current->next->next;

			last->next = NULL;

		} else {

			current = current->next;

		}

	}

	return layout;

}

TextLayout createTextLayout(const char *text)

	{ return createTextLayoutEx(text, strlen(text)); }

TextLayout createTextLayoutf(const char *format, ...) {

	va_list args;

	va_start(args, format);

	va_list args_copy;

	va_copy(args_copy, args);

	int size = vsnprintf(NULL, 0, format, args_copy);

	va_end(args_copy);

	if (size < 0) size = 0;

	++size;

	char *buffer = calloc(1, size);

	vsnprintf(buffer, size, format, args);

	va_end(args);

	TextLayout layout = createTextLayout(buffer);

	free(buffer);

	return layout;

}

void textLayoutDestroy(TextLayout layout) {

	if (layout) {

		free(layout->lines);

		free(layout->chars);

		if (layout->font) fontDestroy(layout->font);

	}

	free(layout);

}

void textLayoutDrawSubstr(TextLayout layout, double x, double y, int start, int length) {

	resetPath();

	if (layout->linesCount <= 0) return;

	assert(layout->lines);

	assert(layout->chars);

	int charsCount = layout->lines[layout->linesCount - 1].end;

	if (charsCount <= 0) return;

	int textEnd = layout->chars[charsCount - 1].charpos;

	int begin = start;

	if (begin < 0) begin = 0;

	long long endll = (long long)begin + length; // to avoid overflow on length == INT_MAX and begin > 0

	if (endll > textEnd) endll = textEnd;

	int end = (int)endll;

	if (begin >= end) return;

	HeliDrawingState *drawingState = heliDrawingGetState();

	double fontScale = drawingState->fontSize/FONT_BASE_SIZE;

	if (fontScale <= HELI_PRECISION) return;

	if ( drawingState->strokeColor[3] <= HELI_PRECISION

	  && drawingState->fillColor[3] <= HELI_PRECISION ) return;

	const double borderK = 0.5*FONT_MAP_BORDERSIZE/FONT_MAP_GLYPHWORKSIZE;

	const double texStep = 1.0/FONT_MAP_CNT;

	const double texBorder = 0.5*FONT_MAP_BORDERSIZE/FONT_MAP_TEXSIZE;

	const double texGlyphSize = (double)FONT_MAP_GLYPHWORKSIZE/FONT_MAP_TEXSIZE;

	if (drawingState->antialiasing && !heliGLIsIntegerClipping())

		glEnable(GL_MULTISAMPLE);

	glPushMatrix();

	glTranslated(x, y, 0);

	glScaled(fontScale, fontScale, 1);

	if (drawingState->fillColor[3] > HELI_PRECISION) {

		double strokeAlpha = drawingState->strokeColor[3];

		drawingState->strokeColor[3] = 0;

		for(int i = 0; i < layout->linesCount; ++i) {

			HeliLineDesc *line = layout->lines + i;

			int found = FALSE;

			double l = 0, r = 0;

			for(int j = line->begin; j < line->end; ++j) {

				HeliCharDesc *cc = layout->chars + j;

				if (cc->charpos < begin || cc->charpos > end) continue;

				if (!found) { l = r = cc->x; found = TRUE; }

				expand(&l, &r, cc->x);

				if (cc->glyph && cc->charpos < end) {

					expand(&l, &r, cc->x + cc->glyph->l);

					expand(&l, &r, cc->x + cc->glyph->r);

				}

			}

			if (found)

				rect(l, line->t + line->y, r-l, line->b - line->t);

		}

		drawingState->strokeColor[3] = strokeAlpha;

	}

	if (drawingState->strokeColor[3] > HELI_PRECISION) {

		glColor4dv(drawingState->strokeColor);

		HeliFontMap *currentMap = NULL;

		glEnable(GL_TEXTURE_2D);

		glBegin(GL_QUADS);

		for(HeliCharDesc *cc = layout->chars; cc; cc = cc->next) {

			if (cc->charpos < begin || cc->charpos >= end) continue;

			if ( !cc->glyph->map

			|| cc->glyph->r - cc->glyph->l <= HELI_PRECISION

			|| cc->glyph->b - cc->glyph->t <= HELI_PRECISION )

				continue;

			if (currentMap != cc->glyph->map) {

				glEnd();

				currentMap = cc->glyph->map;

				glBindTexture(GL_TEXTURE_2D, currentMap->texid);

				glBegin(GL_QUADS);

			}

			double gw = cc->glyph->r - cc->glyph->l;

			double gh = cc->glyph->b - cc->glyph->t;

			double gs = gw > gh ? gw : gh;

			double dx = gs*borderK;

			double dy = gs*borderK;

			double l = cc->x + cc->glyph->l - dx;

			double t = cc->y + cc->glyph->t - dy;