openmohaa/code/uilib/uifont.cpp

/*
===========================================================================
Copyright (C) 2015 the OpenMoHAA team

This file is part of OpenMoHAA source code.

OpenMoHAA source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

OpenMoHAA source code 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 OpenMoHAA source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

#include "ui_local.h"

qboolean UI_FontDBCSIsLeadByte(fontheader_t* font, unsigned short uch);
int UI_FontCodeSearch(const fontheader_t* font, unsigned short uch);

UIFont::UIFont()
{
	m_font = uii.Rend_LoadFont( "verdana-14" );
	if( !m_font ) {
		uii.Sys_Error( ERR_DROP, "Couldn't load font Verdana\n" );
	}

	color = UBlack;
	setColor( color );
}

UIFont::UIFont
	(
	const char *fn
	)

{
	setFont( fn );
}

void UIFont::Print
	(
	float x,
	float y,
	const char *text,
	size_t maxlen,
	qboolean bVirtualScreen
	)

{
	uii.Rend_SetColor( color );
	uii.Rend_DrawString( m_font, text, x, y, maxlen, bVirtualScreen );
}

void UIFont::PrintJustified
	(
	const UIRect2D& rect,
	fonthorzjustify_t horz,
	fontvertjustify_t vert,
	const char *text,
	float *vVirtualScale
	)

{
	float newx, newy;
	int textwidth, textheight;
	UIRect2D sizedRect;
	const char* source;
	char* dest;
	char string[2048];

	if (vVirtualScale)
	{
		sizedRect.pos.x = rect.pos.x / vVirtualScale[0];
		sizedRect.pos.y = rect.pos.y / vVirtualScale[1];
		sizedRect.size.width = rect.size.width / vVirtualScale[0];
		sizedRect.size.height = rect.size.height / vVirtualScale[1];
	}
	else
	{
		sizedRect = rect;
	}

	if (horz == FONT_JUSTHORZ_LEFT && vert == FONT_JUSTVERT_TOP)
	{
		// no need to justify
		Print(sizedRect.pos.x, sizedRect.pos.y, text, -1, vVirtualScale != NULL);
		return;
	}

	textheight = getHeight(text, -1, qfalse);

	switch (vert)
	{
	case FONT_JUSTVERT_TOP:
		newy = sizedRect.pos.y;
		break;
	case FONT_JUSTVERT_CENTER:
		newy = sizedRect.pos.y + (sizedRect.size.height - textheight) * 0.5;
		break;
	case FONT_JUSTVERT_BOTTOM:
		newy = sizedRect.pos.y + sizedRect.size.height - textheight;
		break;
	default:
		newy = 0;
		break;
	}

	source = text;
	while (*source)
	{
		// skip new lines
		while (*source == '\n') {
			source++;
		}

		if (!*source) {
			// don't print an empty string
			return;
		}

		dest = string;

		do
			*dest++ = *source++;
		while (*source && *source != '\n');

		*dest = 0;

		textwidth = getWidth(string, -1);

		switch (horz)
		{
		case FONT_JUSTHORZ_CENTER:
			newx = sizedRect.pos.x + (sizedRect.size.width - textwidth) * 0.5;
			break;
		case FONT_JUSTHORZ_LEFT:
			newx = sizedRect.pos.x;
			break;
		case FONT_JUSTHORZ_RIGHT:
			newx = sizedRect.pos.x + sizedRect.size.width - textwidth;
			break;
		default:
			newx = 0.0;
			break;
		}

		Print(newx, newy, string, -1, vVirtualScale != NULL);

		// expand for newline
		newy += getHeight(" ", -1, qfalse);
	}
}

void UIFont::setColor
	(
	UColor col
	)

{
	color = col;
}

void UIFont::setAlpha
	(
	float alpha
	)

{
	color.a = alpha;
}

void UIFont::setFont
	(
	const char *fontname
	)

{
	m_font = uii.Rend_LoadFont( fontname );
	if( !m_font ) {
		uii.Sys_Error( ERR_DROP, "Couldn't load font %s\n", fontname );
	}
}

int UIFont::getWidth
	(
	const char *text,
	int maxlen
	)

{
	return UI_FontStringWidth( m_font, text, maxlen );
}

int UIFont::getCharWidth
	(
	unsigned short ch
	)

{
	int index;
	int indirected;

	if (!m_font) {
		return 0;
	}

	if (ch == '\t') {
		ch = ' ';
	}

	if (m_font->numPages)
	{
		int code = CodeSearch(ch);
		if (code < 0) {
			return 0;
		}

		index = m_font->charTable[code].index;
		indirected = m_font->charTable[code].loc;
	}
	else
	{
		indirected = m_font->sgl[0]->indirection[ch];
		if (indirected < 0 || indirected > 255) {
			return 0;
		}

		index = 0;
	}

    if (ch == '\t') {
        return m_font->sgl[index]->locations[indirected].size[0] * 256.0 * 3.0;
	} else {
		return m_font->sgl[index]->locations[indirected].size[0] * 256.0;
	}
}

int UIFont::getHeight
	(
	const char *text,
	int maxlen,
	qboolean bVirtual
	)

{
	float height;
	int i;

	if( !m_font ) {
		return 0;
	}

	height = getHeight( bVirtual );

	for(i = 0; text[i]; i++)
	{
		if( maxlen != -1 && i > maxlen ) {
			break;
		}

		if( text[ i ] == '\n' )
		{
			height += getHeight( bVirtual );
		}
	}

	return height;
}

int UIFont::getHeight
	(
	qboolean bVirtual
	)

{
	if( bVirtual )
	{
		if( m_font )
		{
			return ( m_font->sgl[0]->height * uid.vidHeight / 480.0 );
		}
		else
		{
			return ( 16.0 * uid.vidHeight / 480.0 );
		}
	}
	else
	{
		if( m_font )
		{
			return m_font->sgl[0]->height;
		}
		else
		{
			return 16;
		}
	}
}

int UIFont::CodeSearch(unsigned short uch)
{
	return UI_FontCodeSearch(m_font, uch);
}

qboolean UI_FontDBCSIsLeadByte(fontheader_t* font, unsigned short uch)
{
    // Byte ranges found in Wikipedia articles with relevant search strings in each case
    switch (font->codePage) {
    case 932:
        // Shift_jis
        return ((uch >= 0x81) && (uch <= 0x9F)) ||
            ((uch >= 0xE0) && (uch <= 0xFC));
        // Lead bytes F0 to FC may be a Microsoft addition.
    case 936:
        // GBK
        return (uch >= 0x81) && (uch <= 0xFE);
    case 949:
        // Korean Wansung KS C-5601-1987
        return (uch >= 0x81) && (uch <= 0xFE);
    case 950:
        // Big5
        return (uch >= 0x81) && (uch <= 0xFE);
    case 1361:
        // Korean Johab KS C-5601-1992
        return
            ((uch >= 0x84) && (uch <= 0xD3)) ||
            ((uch >= 0xD8) && (uch <= 0xDE)) ||
            ((uch >= 0xE0) && (uch <= 0xF9));
    }
    return false;
}

int UI_FontCodeSearch(const fontheader_t* font, unsigned short uch) {
    int mid;
    int l, r;

    r = font->charTableLength;
    l = 0;
    while (l < r) {
        mid = (l + r) / 2;

        if (font->charTable[mid].cp > uch) {
            r = (l + r) / 2;
            continue;
        }

        if (uch == font->charTable[mid].cp) {
            return (l + r) / 2;
        }

        l = mid + 1;
    }

    if (uch != font->charTable[l].cp) {
        return -1;
    }

    return l;
}

float UI_FontgetCharWidthf(fontheader_t* font, unsigned short uch)
{
	int index;
	int indirected;

	if (!font) {
		return 0.f;
	}

	if (uch == '\t') {
		uch = ' ';
	}

	if (font->numPages)
	{
		int code = UI_FontCodeSearch(font, uch);
		if (code < 0) {
			return 0.f;
		}

		index = font->charTable[code].index;
		indirected = font->charTable[code].loc;
	}
	else
	{
		indirected = font->sgl[0]->indirection[uch];
		if (indirected < 0 || indirected > 255) {
			return 0.f;
		}

		index = 0;
	}

	if (uch == '\t') {
		return font->sgl[index]->locations[indirected].size[0] * 3.0;
	} else {
		return font->sgl[index]->locations[indirected].size[0];
	}
}

int UI_FontStringMaxWidth
	(
	fontheader_t *pFont,
	const char *pszString,
	int iMaxLen
	)

{
    float widths = 0.0;
    float maxwidths = iMaxLen / 256.0f;
    int i;

    if (!pFont) {
        return 0;
    }

	i = 0;
    for(;;)
    {
        unsigned short uch = pszString[i++];

        if (uch == 0 || (iMaxLen != -1 && i > iMaxLen))
        {
            break;
        }

		if (UI_FontDBCSIsLeadByte(pFont, uch))
		{
			uch = (uch << 8) | pszString[i];
			if (!pszString[i]) {
				break;
			}

			i++;
		}

        if (uch == '\n')
        {
            widths = 0.0;
        }
        else
        {
            widths += UI_FontgetCharWidthf(pFont, uch);

            if (maxwidths < widths) {
                return i - 1;
            }
        }
    }

    return -1;
}

int UI_FontStringWidth
	(
	fontheader_t *pFont,
	const char *pszString,
	int iMaxLen
	)

{
    float widths = 0.0;
    float maxwidths = 0.0;
    int i;

    if (!pFont) {
        return 0;
    }

	i = 0;
    for(;;)
    {
        unsigned short uch = pszString[i++];

        if (uch == 0 || (iMaxLen != -1 && i > iMaxLen))
        {
            break;
        }

		if (UI_FontDBCSIsLeadByte(pFont, uch))
		{
			uch = (uch << 8) | pszString[i];
			if (!pszString[i]) {
				break;
			}

			i++;
		}

        if (uch == '\n')
        {
            widths = 0.0;
        }
        else
        {
            widths += UI_FontgetCharWidthf(pFont, uch);

            if (maxwidths < widths) {
                maxwidths = widths;
            }
        }
    }

    return maxwidths * 256.0;
}