Hard reset

code/uilib/uifont.cpp

@@ -0,0 +1,352 @@
+/*
+===========================================================================
+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"
+
+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,
+	int 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[ 2 ];
+		sizedRect.size.height = rect.size.height / vVirtualScale[ 3 ];
+	}
+	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.size.height - textheight ) * 0.5 + sizedRect.pos.y;
+		break;
+	case FONT_JUSTVERT_BOTTOM:
+		newy = sizedRect.pos.y - textheight;
+		break;
+	default:
+		newy = 0;
+		break;
+	}
+
+	source = text;
+	while( *source )
+	{
+		while( *source == '\n' )
+			source++;
+
+		if( !*source )
+			return;
+
+		dest = string;
+
+		do
+			*dest++ = *source++;
+		while( *source && *source != '\n' );
+
+		*dest = 0;
+
+		textwidth = getWidth( string, -1 );
+
+		switch( horz )
+		{
+		case FONT_JUSTHORZ_CENTER:
+			newx = ( sizedRect.size.width - textwidth ) * 0.5 + sizedRect.pos.x;
+			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
+	(
+	char ch
+	)
+
+{
+	int indirected = m_font->indirection[ 32 ];
+
+	if( ch == '\t' )
+	{
+		indirected = m_font->indirection[ 32 ];
+
+		if( indirected > 255 ) {
+			Com_Printf( "getCharWidth: no space-character in font!\n" );
+			return 0;
+		}
+
+		return m_font->locations[ indirected ].size[ 0 ] * 256.0 * 3.0;
+	}
+	else
+	{
+		indirected = m_font->indirection[ ch ];
+
+		if( indirected > 255 ) {
+			Com_Printf( "getCharWidth: no 0x%02x-character in font!\n", ch );
+			return 0;
+		}
+
+		return m_font->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 );
+
+	i = 0;
+	while( text[ 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->height * uid.vidHeight / 480.0 );
+		}
+		else
+		{
+			return ( 16.0 * uid.vidHeight / 480.0 );
+		}
+	}
+	else
+	{
+		if( m_font )
+		{
+			return m_font->height;
+		}
+		else
+		{
+			return 16;
+		}
+	}
+}
+
+int UI_FontStringWidth
+	(
+	fontheader_t *pFont,
+	const char *pszString,
+	int iMaxLen
+	)
+
+{
+	float widths = 0.0;
+	float maxwidths = 0.0;
+	int indirected;
+	int i;
+
+	if( !pFont ) {
+		return 0;
+	}
+
+	if( iMaxLen == -1 ) {
+		iMaxLen = strlen( pszString ) + 1;
+	}
+
+	for( i = 0; i < iMaxLen; i++ )
+	{
+		unsigned char c = pszString[ i ];
+
+		if( c == 0 )
+		{
+			break;
+		}
+		else if( c == '\t' )
+		{
+			indirected = pFont->indirection[ 32 ];
+
+			if( indirected > 255 ) {
+				Com_Printf( "UIFont::getWidth: no space-character in font!\n" );
+				continue;
+			} else {
+				widths += pFont->locations[ indirected ].size[ 0 ] * 3.0;
+			}
+		}
+		else if( c == '\n' )
+		{
+			widths = 0.0;
+		}
+		else
+		{
+			indirected = pFont->indirection[ c ];
+
+			if( indirected > 255 ) {
+				Com_Printf( "UIFont::getWidth: no 0x%02x-character in font!\n", c );
+				continue;
+			} else {
+				widths += pFont->locations[ indirected ].size[ 0 ];
+			}
+		}
+
+		if( maxwidths < widths ) {
+			maxwidths = widths;
+		}
+	}
+
+	return maxwidths * 256.0;
+}