nigger/CnC_Generals_Zero_Hour
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
CnC_Generals_Zero_Hour/GeneralsMD/Code/Tools/Autorun/TTFont.cpp

1476 lines
59 KiB
C++
Raw Permalink Blame History

/*
** Command & Conquer Generals Zero Hour(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program 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 3 of the License, or
** (at your option) any later version.
**
** This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
/************************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
************************************************************************************************
* *
* Project Name: Setup *
* *
* Archive: TTFont.cpp *
* *
* Author: Maria del Mar McCready Legg *
* *
* Modtime: 8/24/99 3:44pm *
* *
* Revision: 01 *
* *
*----------------------------------------------------------------------------------------------*
* Functions: *
* TTFontClass::TTFontClass -- Constructor for a font class object. *
* TTFontClass::Char_Pixel_Width -- Fetch the pixel width of the character specified. *
* TTFontClass::Find_Text_VLength -- Finds length of text in pixels *
* TTFontClass::Get_Height -- Fetch the normalized height of the nominal font character. *
* TTFontClass::Get_Width -- Get normalized width of the nominal font character. *
* TTFontClass::Print -- Print text to the surface specified. *
* TTFontClass::Raw_Height -- Fetch the height of the font. *
* TTFontClass::Raw_Width -- Fetch the raw width of a character. *
* TTFontClass::Set_XSpacing -- Set the X spacing override value. *
* TTFontClass::Set_YSpacing -- Set the vertical (Y) spacing override value. *
* TTFontClass::String_Pixel_Width -- Determines the width of the string in pixels. *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
#define STRICT
#include <windows.h>
#include <windowsx.h>
#include <assert.h>
#include <ctype.h>
#include <stdlib.h>
#include "args.h"
#include "autorun.h"
#include "rect.h"
#include "wnd_file.h"
#include "ttfont.h"
#include "jsupport.h" // [OYO]
#include "locale_api.h"
#define FONTINFOMAXHEIGHT 4
#define FONTINFOMAXWIDTH 5
#define FUDGEDIV 16
//-------------------------------------------------------------------------
// Text Fonts.
//-------------------------------------------------------------------------
TTFontClass *TTButtonFontPtr = NULL;
TTFontClass *TTButtonFontPtrSmall = NULL;
TTFontClass *TTTextFontPtr = NULL;
TTFontClass *TTTextFontPtr640 = NULL;
TTFontClass *TTTextFontPtr800 = NULL;
TTFontClass *TTLicenseFontPtr = NULL;
FontManagerClass * FontManager = NULL;
//unsigned long TEXT_COLOR = RGB( 247, 171, 11 );
//unsigned long SHADOW_COLOR = RGB( 40, 8, 8 );
unsigned long TEXT_COLOR = RGB( 255, 204, 51 );
unsigned long SHADOW_COLOR = RGB( 40, 8, 8 );
unsigned long TEXT_NORMAL_COLOR = RGB( 255, 204, 51 );
unsigned long TEXT_NORMAL_SHADOW_COLOR = RGB( 40, 8, 8 );
unsigned long TEXT_FOCUSED_COLOR = RGB( 255, 204, 51 );
unsigned long TEXT_FOCUSED_SHADOW_COLOR = RGB( 40, 8, 8 );
unsigned long TEXT_PRESSED_COLOR = RGB( 194, 79, 32 );
unsigned long TEXT_PRESSED_SHADOW_COLOR = RGB( 70, 55, 49 );
unsigned long BLACK_COLOR = RGB( 0, 0, 0 );
unsigned long WHITE_COLOR = RGB( 255, 255, 255 );
unsigned long RED_COLOR = RGB( 255, 0, 0 );
unsigned long ORANGE_COLOR = RGB( 199, 91, 0 );
unsigned long YELLOW_COLOR = RGB( 255, 247, 0 );
unsigned long GREEN_COLOR = RGB( 0, 255, 0 );
unsigned long BLUE_COLOR = RGB( 0, 0, 255 );
unsigned long INDIGO_COLOR = RGB( 90, 2, 253 );
unsigned long VIOLET_COLOR = RGB( 128, 0, 255 );
/************************************************************************************
* TTFontClass::TTFontClass -- Constructor for a font class object. *
* *
* This constructs a font object as it is based upon the true type windows fonts. *
* *
* INPUT: char *filename -- True Type Windows font file to open. *
* char *facename -- It's face name. *
* int height -- The height requested. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/24/1999 MML : Created. *
*==================================================================================*/
TTFontClass::TTFontClass(
HDC hdc,
char *filename,
char *facename,
int height,
int weight,
BYTE charset,
int width,
int escapement,
int orientation,
BYTE italic,
BYTE underline,
BYTE strikeout,
BYTE outputPrecision,
BYTE clipPrecision,
BYTE quality,
BYTE pitchAndFamily )
{
HGDIOBJ old_object;
TEXTMETRIC tm;
char real_facename[MAX_PATH];
//--------------------------------------------------------------------------
// Get or Set a Font filename.
//--------------------------------------------------------------------------
if (( filename == NULL ) || ( filename[0] == '\0' )) {
strcpy( szFilename, "Arial.ttf" );
} else {
strcpy( szFilename, filename );
}
//--------------------------------------------------------------------------
// Get or Set a Font facename.
//--------------------------------------------------------------------------
if (( facename == NULL ) || ( facename[0] == '\0' )) {
strcpy( szFacename, "Arial" );
} else {
strcpy( szFacename, facename );
}
real_facename[0] = '\0';
Msg( __LINE__, __FILE__, "TTFontClass -- filename=%s, facename=%s, height=%d.", filename, facename, height );
//--------------------------------------------------------------------------
// Make sure the font file is "Registered". Then create the font.
//--------------------------------------------------------------------------
AddFontResource( szFilename );
Font = CreateFont(
height,
width,
escapement,
orientation,
weight,
italic,
underline,
strikeout,
charset,
outputPrecision,
clipPrecision,
quality,
pitchAndFamily,
szFacename );
if ( hdc && ( Font != NULL )) {
//----------------------------------------------------------------------
// The GetTextFace function lets a program determine the face name of
// THE font currently selected in the device context:
//----------------------------------------------------------------------
old_object = SelectObject( hdc, Font );
GetTextFace( hdc, ( sizeof( real_facename ) / sizeof( TCHAR )), real_facename );
if( _stricmp( real_facename, szFacename ) != 0 ) {
strcpy( szFilename, "Arial.ttf" );
strcpy( szFacename, "Arial" );
SelectObject( hdc, old_object );
DeleteObject( Font );
Font = NULL;
Font = CreateFont(
height, // height of font
width, // average character width
escapement, // angle of escapement
orientation, // base-line orientation angle
weight, // font weight
italic, // italic attribute option
underline, // underline attribute option
strikeout, // strikeout attribute option
charset, // character set identifier
outputPrecision, // output precision
clipPrecision, // clipping precision
quality, // output quality
pitchAndFamily, // pitch and family
szFacename ); // typeface name
real_facename[0] = '\0';
old_object = SelectObject( hdc, Font );
GetTextFace( hdc, ( sizeof( real_facename ) / sizeof( TCHAR )), real_facename );
}
}
//--------------------------------------------------------------------------
// Save off the height.
//--------------------------------------------------------------------------
Height = height;
if ( hdc ) {
//-----------------------------------------------------------------------
// Get info from the font in BackBuffer's DC.
//-----------------------------------------------------------------------
old_object = SelectObject( hdc, Font );
GetTextMetrics( hdc, &tm );
FontXSpacing = GetTextCharacterExtra( hdc );
Ascent = tm.tmAscent;
Descent = tm.tmDescent;
InternalLeading = tm.tmInternalLeading;
ExternalLeading = tm.tmExternalLeading;
AveCharWidth = tm.tmAveCharWidth;
MaxCharWidth = tm.tmMaxCharWidth;
Overhang = tm.tmOverhang;
Italic = tm.tmItalic;
Underlined = tm.tmUnderlined;
StruckOut = tm.tmStruckOut;
CharSet = tm.tmCharSet; // [OYO] It is important to support Double Byte Chars
SelectObject( hdc, old_object );
} else {
//-----------------------------------------------------------------------
// Set default values.
//-----------------------------------------------------------------------
Ascent = 0;
Descent = 0;
InternalLeading = 0;
ExternalLeading = 0;
AveCharWidth = 0;
MaxCharWidth = 0;
Overhang = 0;
Italic = 0;
Underlined = 0;
StruckOut = 0;
CharSet = 0; // [OYO]
FontXSpacing = 0;
}
}
/***********************************************************************************************
* TTFontClass::Char_Pixel_Width -- Fetch the pixel width of the character specified. *
* *
* This will return with the pixel width of the character specified. *
* *
* INPUT: c -- The character to determine the pixel width for. *
* *
* OUTPUT: Returns with the pixel width of the character. *
* *
* WARNINGS: The return width is the screen real estate width which may differ from the *
* actual pixels of the character. This difference is controlled by the font *
* X spacing. *
* *
* HISTORY: *
* 05/26/1997 JLB : Created. *
*=============================================================================================*/
int TTFontClass::Char_Pixel_Width( HDC hdc, UINT c ) const
{
HGDIOBJ old_object;
ABC abc;
abc.abcA = 0;
abc.abcB = 0;
abc.abcC = 0;
if ( hdc ) {
old_object = SelectObject( hdc, Font );
GetCharABCWidths( hdc, c, c, &abc );
SelectObject( hdc, old_object );
}
return( abc.abcA + abc.abcB + abc.abcC );
}
/************************************************************************************************
* TTFontClass::Char_Pixel_Width -- Fetch the pixel width of the character specified.
*
* This will return with the pixel width of the character specified.
*
* INPUT: HDC hdc -- must be passed in from calling function.
* char const * string -- the pointer to the character in the string.
* int *num_bytes -- return number of bytes this character has: 1 or 2.
*
* OUTPUT: Returns with the pixel width of the character.
*
* WARNINGS: The return width is the screen real estate width which may differ from the
* actual pixels of the character. This difference is controlled by the font
* X spacing.
*
* NOTE: This is function determines if the character is a double-byte or single-byte
* character, then calls the standard Char_Pixel_Width.
*
* HISTORY:
* 05/26/1997 JLB : Created.
*==============================================================================================*/
//
// [OYO] Supports DBCS ( multi-byte characters ).
//
int TTFontClass::Char_Pixel_Width ( HDC hdc, char const * string, int *num_bytes ) const
{
char const *letter = string;
int length = 0;
UINT c;
//--------------------------------------------------------------------------
// These values must be passed in.
//--------------------------------------------------------------------------
if ( string == NULL || *string == '\0' || hdc == NULL ) {
return( 0 );
}
//--------------------------------------------------------------------------
// If this value is passed in, the set the default value (1=single).
//--------------------------------------------------------------------------
if ( num_bytes!= NULL ) {
*num_bytes = 1;
}
//--------------------------------------------------------------------------
// Get the pixel width of the character. If it is a double-byte character,
// then num_bytes will come back as '2'.
//--------------------------------------------------------------------------
if( IsFontDBCS() && IsDBCSLeadByte( *letter )){
c = Get_Double_Byte_Char( letter, num_bytes );
length += Char_Pixel_Width( hdc, c ); // pixel length of double-byte character.
} else {
length += Char_Pixel_Width( hdc, *letter ); // pixel length of single-byte character.
}
return( length );
}
/************************************************************************************************
* TTFontClass::String_Pixel_Width -- Determines the width of the string in pixels. *
* *
* This routine is used to determine how many pixels wide the string will be if it were *
* printed. *
* *
* INPUT: string -- The string to convert into its pixel width. *
* *
* OUTPUT: Returns with the number of pixels the string would span if it were printed. *
* *
* WARNINGS: This routine does not take into account clipping. *
* *
* HISTORY: *
* 05/26/1997 JLB : Created. *
*==============================================================================================*/
int TTFontClass::String_Pixel_Width( HDC hdc, char const * string ) const
{
if ( string == NULL ) {
return(0);
}
int largest = 0; // Largest recorded width of the string.
int width = 0;
HGDIOBJ old_object;
int length;
SIZE size;
bool make_dc = FALSE;
HDC localDC = hdc;
size.cx = 0;
if ( localDC == NULL ) {
return( size.cx );
}
if ( localDC ) {
length = strlen( string );
old_object = SelectObject( localDC, Font );
GetTextExtentPoint32( localDC, string, length, &size );
SelectObject( localDC, old_object );
}
return( size.cx );
}
/****************************************************************************
*
* NAME
* String_Pixel_Bounds(String, Bounds)
*
* DESCRIPTION
* Calculate the bounding box for the specified string.
*
* INPUTS
* String - String to calculate bounds for
* Bounds - Rect to fill with bounds
*
* RESULT
* NONE
*
****************************************************************************/
//
// [OYO] Supports DBCS ( multi-byte characters ).
//
void TTFontClass::String_Pixel_Bounds( HDC hdc, const char* string, Rect& bounds ) const
{
int width;
int height;
bounds.Width = 0;
bounds.Height = 0;
if ( string == NULL ) {
return;
}
if ( hdc == NULL ) {
return;
}
width = 0;
height = Get_Height();
while ( *string != 0 ) {
if (( *string == '\r' ) || ( *string == '\n' )) {
string++;
height += Get_Height();
bounds.Width = max( bounds.Width, width );
width = 0;
} else if( IsFontDBCS()){
#if(0)
//--------------------------------------------------------------------
// Using one of those _tc functions:
// Get a character, get the width of that character, then
// move the pointer to the next character.
//--------------------------------------------------------------------
UINT c = Get_Double_Byte_Char( string );
width += Char_Pixel_Width( hdc, c );
string = _tcsinc( string );
#else
//--------------------------------------------------------------------
// MBCS way: Get a byte. If byte is a "Lead" byte, get the second half,
// combine them into one character, then get the width of that character.
//--------------------------------------------------------------------
UINT c = *(BYTE*)string++;
if( IsDBCSLeadByte( c )&& *string ) {
c = ( c << 8 ) | *(BYTE *)string++;
}
width += Char_Pixel_Width( hdc, c );
#endif
} else {
width += Char_Pixel_Width( hdc, *string++ );
}
}
bounds.Width = max( bounds.Width, width );
bounds.Height = height;
}
/***********************************************************************************************
* TTFontClass::Get_Double_Byte_Char -- Get the first character even if DBSC.
*
* INPUT: char * -- string to look at.
*
* OUTPUT: Returns with the normalized width of the character in the font.
*
* WARNINGS: I added this function based on code provided by Ikeda-san.
*
* HISTORY:
* 06/05/2000 MML : Created.
*=============================================================================================*/
//
// [OYO] Supports DBCS ( multi-byte characters ).
//
UINT TTFontClass::Get_Double_Byte_Char ( const char *string, int *num_bytes ) const
{
if ( string == NULL || *string == '\0' ) {
return( 0 );
}
const char *ptr = string;
UINT c = *(BYTE *)ptr++;
if ( num_bytes != NULL ) {
*num_bytes = 1;
}
//--------------------------------------------------------------------------
// The IsDBCSLeadByte function determines whether a character is a
// lead byte <20> that is, the first byte of a character in a double-byte
// character set (DBCS).
//
// BOOL IsDBCSLeadByte( BYTE TestChar /* character to test */ );
//
// TestChar -- Specifies the character to be tested.
//
// Return Values
// If the character is a lead byte, the return value is nonzero.
// If the character is not a lead byte, the return value is zero.
// To get extended error information, call GetLastError.
// Remarks
// Lead bytes are unique to double-byte character sets.
// A lead byte introduces a double-byte character. Lead bytes
// occupy a specific range of byte values. The IsDBCSLeadByte
// function uses the ANSI code page to check lead-byte ranges.
// To specify a different code page, use the IsDBCSLeadByteEx function.
//
// Declared in winnls.h.
//--------------------------------------------------------------------------
if( IsDBCSLeadByte( c )&& *ptr ) { // [OYO]
c = ( c << 8 ) | *(BYTE *)ptr++;
if ( num_bytes != NULL ) {
*num_bytes = 2;
}
}
return( c );
}
/***********************************************************************************************
* TTFontClass::Get_Width -- Get normalized width of the nominal font character. *
* *
* This routine is used to fetch the width of the widest character in the font but the *
* width has been biased according to any X spacing override present. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the normalized width of the widest character in the font. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/26/1997 JLB : Created. *
*=============================================================================================*/
int TTFontClass::Get_Width( void ) const
{
return( MaxCharWidth - Overhang );
}
/***********************************************************************************************
* TTFontClass::Get_Height -- Fetch the normalized height of the nominal font character. *
* *
* This will return the height of the font but the returned height will be adjusted by any *
* Y spacing override present. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the height of the font normalized by any spacing overrides. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/26/1997 JLB : Created. *
*=============================================================================================*/
int TTFontClass::Get_Height( void ) const
{
return( Height );
}
/***********************************************************************************************
* TTFontClass::Set_XSpacing -- Set the X spacing override value. *
* *
* Use this routine to control the horizontal spacing override for this font. If the value *
* is negative, the font becomes compressed. If the value is positive, then the font *
* becomes expanded. *
* *
* INPUT: x -- The X spacing override to use for this font. *
* *
* OUTPUT: Returns with the old X spacing override value. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/26/1997 JLB : Created. *
*=============================================================================================*/
int TTFontClass::Set_XSpacing( HDC hdc, int x )
{
// HGDIOBJ old_object;
// int answer = 0;
// if ( hdc ) {
// old_object = SelectObject( hdc, Font );
// answer = SetTextCharacterExtra( hdc, x );
// SelectObject( hdc, old_object );
// }
FontXSpacing = x;
return( x );
}
/***********************************************************************************************
* TTFontClass::Set_YSpacing -- Set the vertical (Y) spacing override value. *
* *
* Use this routine to control the "line spacing" of a font. If the Y spacing is negative *
* then the font becomes closer to the line above it. If value is positive, then more *
* space occurs between lines. *
* *
* INPUT: y -- The Y spacing override to use for this font. *
* *
* OUTPUT: Returns with the old Y spacing override value. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/26/1997 JLB : Created. *
*=============================================================================================*/
int TTFontClass::Set_YSpacing( int y )
{
FontYSpacing = y;
return(y);
}
/***********************************************************************************************
* TTFontClass::Print -- Print text to the surface specified. WCHAR Version. *
* *
* This displays text to the surface specified and with the attributes specified. *
* *
* INPUT: string -- The string to display to the surface. *
* surface -- The surface to display the text upon. *
* cliprect -- The clipping rectangle that both clips the text and biases the print *
* location to. *
* point -- The draw position for the upper left corner of the first character. *
* convert -- The pixel convert object that is used to draw the correct colors to *
* the destination surface. *
* remap -- Auxiliary remap table for font colors. *
* *
* OUTPUT: Returns with the point where the next print should begin if it is to smoothly *
* continue where this print operation left off. *
* *
* WARNINGS: There are two separate drawing routines; one for old fonts and one for new fonts. *
* *
* HISTORY: *
* 05/26/1997 JLB : Created. *
* 06/20/1887 BNA : Modified to handle new fonts. *
*=============================================================================================*/
#if(NDEBUG)
Point2D TTFontClass::Print(
HDC hdc,
wchar_t const * string,
Rect const & cliprect,
COLORREF forecolor, /* = TEXT_COLOR, */
COLORREF backcolor, /* = TEXT_SHADOW_COLOR, */
TextFormatType flag, /* = TPF_DEFAULT, */
TextShadowType shadow ) /* = TPF_FULLSHADOW */
{
char buffer[ _MAX_PATH ];
int length = wcslen( string );
memset( buffer, '\0', _MAX_PATH );
WideCharToMultiByte( CodePage, 0, string, length, buffer, _MAX_PATH, NULL, NULL );
return( Print( hdc, buffer, cliprect, forecolor, backcolor, flag, shadow ));
}
#else
Point2D TTFontClass::Print(
HDC hdc,
wchar_t const * string,
Rect const & cliprect,
COLORREF forecolor, /* = TEXT_COLOR, */
COLORREF backcolor, /* = TEXT_SHADOW_COLOR, */
TextFormatType flag, /* = TPF_DEFAULT, */
TextShadowType shadow ) /* = TPF_FULLSHADOW */
{
Point2D point( cliprect.X, cliprect.Y );
RECT rect;
HGDIOBJ old_object;
SIZE size;
int length = 0;
int result = 0;
//--------------------------------------------------------------------------
// If no string, why continue?
//--------------------------------------------------------------------------
assert( string != NULL );
assert( hdc != NULL );
if (( string == NULL ) || ( string[0] == '\0' )) {
return( point );
}
//--------------------------------------------------------------------------
// Set up rectangle print regions for the "shadow" and the main color.
//--------------------------------------------------------------------------
length = wcslen( string );
rect.left = cliprect.X;
rect.top = cliprect.Y;
rect.right = cliprect.X + cliprect.Width;
rect.bottom = cliprect.Y + cliprect.Height;
Msg( __LINE__, __FILE__, "TTFontClass::Print -- string = %s.", string );
Msg( __LINE__, __FILE__, "TTFontClass::Print -- strlen = %d.", length );
Msg( __LINE__, __FILE__, "TTFontClass::Print -- rect = [%d, %d, %d, %d].", rect.left, rect.top, rect.right, rect.bottom );
// Msg( __LINE__, __FILE__, "TTFontClass::Print -- rect2 = [%d, %d, %d, %d].", rect.left, rect.top, rect.right, rect.bottom );
//--------------------------------------------------------------------------
// Print the "Shadow" depending on style desired, then the text in the requested color.
//--------------------------------------------------------------------------
if ( hdc ) {
assert( Font != NULL );
old_object = SelectObject( hdc, Font );
SetTextCharacterExtra( hdc, FontXSpacing );
SetTextAlign( hdc, TA_LEFT | TA_TOP );
SetBkMode( hdc, TRANSPARENT );
SetTextColor( hdc, forecolor );
// result = ExtTextOutW(
// hdc, // handle to DC
// rect.left, // x-coordinate of reference point
// rect.top, // y-coordinate of reference point
// ETO_CLIPPED, // text-output options
// &rect, // optional dimensions
// string, // string
// length, // number of characters in string
// NULL // array of spacing values
// );
// result = TextOutW(
// hdc, // handle to DC
// rect.left, // x-coordinate of starting position
// rect.top, // y-coordinate of starting position
// string, // character string
// length // number of characters
// );
result = DrawTextW(
hdc,
string,
length,
&rect,
flag );
GetTextExtentPointW( hdc, string, length, &size );
SelectObject( hdc, old_object );
}
point.X += size.cx;
return( point );
}
#endif
/***********************************************************************************************
* TTFontClass::Print -- Print text to the surface specified. CHAR version. *
* *
* This displays text to the surface specified and with the attributes specified. *
* *
* INPUT: string -- The string to display to the surface. *
* surface -- The surface to display the text upon. *
* cliprect -- The clipping rectangle that both clips the text and biases the print *
* location to. *
* point -- The draw position for the upper left corner of the first character. *
* convert -- The pixel convert object that is used to draw the correct colors to *
* the destination surface. *
* remap -- Auxiliary remap table for font colors. *
* *
* OUTPUT: Returns with the point where the next print should begin if it is to smoothly *
* continue where this print operation left off. *
* *
* WARNINGS: There are two separate drawing routines; one for old fonts and one for new fonts. *
* *
* HISTORY: *
* 05/26/1997 JLB : Created. *
* 06/20/1887 BNA : Modified to handle new fonts. *
*=============================================================================================*/
Point2D TTFontClass::Print(
HDC hdc,
char const * string,
Rect const & cliprect,
COLORREF forecolor, /* = TEXT_COLOR, */
COLORREF backcolor, /* = TEXT_SHADOW_COLOR, */
TextFormatType flag, /* = TPF_DEFAULT, */
TextShadowType shadow ) /* = TPF_FULLSHADOW */
{
Point2D point( cliprect.X, cliprect.Y );
RECT rect, rect2;
HGDIOBJ old_object;
SIZE size;
int length = 0;
int result = 0;
//--------------------------------------------------------------------------
// If no string, why continue?
//--------------------------------------------------------------------------
assert( string != NULL );
assert( hdc != NULL );
if (( string == NULL ) || ( string[0] == '\0' )) {
return( point );
}
//--------------------------------------------------------------------------
// Set up rectangle print regions for the "shadow" and the main color.
//--------------------------------------------------------------------------
length = strlen( string );
rect.left = cliprect.X;
rect.top = cliprect.Y;
rect.right = cliprect.X + cliprect.Width;
rect.bottom = cliprect.Y + cliprect.Height;
// Shadow
rect2.left = rect.left - 1;
rect2.top = rect.top - 1;
rect2.right = rect.right - 1;
rect2.bottom= rect.bottom - 1;
// Msg( __LINE__, __FILE__, "TTFontClass::Print -- strlen = %d.", length );
// Msg( __LINE__, __FILE__, "TTFontClass::Print -- rect = [%d, %d, %d, %d].", rect.left, rect.top, rect.right, rect.bottom );
// Msg( __LINE__, __FILE__, "TTFontClass::Print -- rect2 = [%d, %d, %d, %d].", rect.left, rect.top, rect.right, rect.bottom );
//--------------------------------------------------------------------------
// Print the "Shadow" depending on style desired, then the text in the requested color.
//--------------------------------------------------------------------------
if ( hdc ) {
assert( Font != NULL );
old_object = SelectObject( hdc, Font );
SetTextCharacterExtra( hdc, FontXSpacing );
SetTextAlign( hdc, TA_LEFT | TA_TOP );
SetBkMode( hdc, TRANSPARENT );
SetTextColor( hdc, backcolor );
if ( shadow == TPF_SHADOW ) {
// One left, One up.
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// One left.
rect2.left = rect.left - 1;
rect2.top = rect.top;
rect2.right = rect.right - 1;
rect2.bottom = rect.bottom;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// One up.
rect2.left = rect.left;
rect2.top = rect.top - 1;
rect2.right = rect.right;
rect2.bottom = rect.bottom - 1;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
} else if ( shadow == TPF_DOUBLESHADOW ) {
// One left, One up.
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// One left.
rect2.left = rect.left - 1;
rect2.top = rect.top;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// One up.
rect2.left = rect.left;
rect2.top = rect.top - 1;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// Two left, Two up.
rect2.left = rect.left - 2;
rect2.top = rect.top - 2;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// Two left.
rect2.left = rect.left - 2;
rect2.top = rect.top;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// Two up.
rect2.left = rect.left;
rect2.top = rect.top - 2;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
} else if ( shadow == TPF_FULLSHADOW ) {
// One left, One up.
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// One right, One up.
rect2.left = rect.left + 1;
rect2.top = rect.top - 1;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// One left, One down.
rect2.left = rect.left - 1;
rect2.top = rect.top + 1;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// One right, One down.
rect2.left = rect.left + 1;
rect2.top = rect.top + 1;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// One left.
rect2.left = rect.left - 1;
rect2.top = rect.top;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// One right.
rect2.left = rect.left + 1;
rect2.top = rect.top;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// One up.
rect2.left = rect.left;
rect2.top = rect.top - 1;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// One down.
rect2.left = rect.left;
rect2.top = rect.top + 1;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// Two right.
rect2.left = rect.left + 2;
rect2.top = rect.top;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// Two down.
rect2.left = rect.left;
rect2.top = rect.top + 2;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// Two right, One up.
rect2.left = rect.left + 2;
rect2.top = rect.top - 2;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// Two right, One down.
rect2.left = rect.left + 2;
rect2.top = rect.top + 2;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// Three right.
rect2.left = rect.left + 3;
rect2.top = rect.top;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// Three down.
rect2.left = rect.left;
rect2.top = rect.top + 3;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// Three right, One up.
rect2.left = rect.left + 3;
rect2.top = rect.top - 3;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
// Three right, One down.
rect2.left = rect.left + 3;
rect2.top = rect.top + 3;
result = DrawText( hdc, string, length, &rect2, flag );
assert( result != 0 );
}
SetTextColor( hdc, forecolor );
result = DrawText( hdc, string, length, &rect, flag );
assert( result != 0 );
GetTextExtentPoint( hdc, string, length, &size );
SelectObject( hdc, old_object );
}
point.X += size.cx;
return( point );
}
/***************************************************************************
* TTFontClass::FIND_TEXT_VLENGTH -- Finds length of text in pixels *
* *
* INPUT: BYTE *string - the strength to find the vertical length of *
* int width - the width of the region to fit it in *
* *
* OUTPUT: int -- the number of pixels it takes up veritcally. *
* *
* HISTORY: *
* 09/27/1994 PWG : Created. *
*=========================================================================*/
//
// [OYO] Supports DBCS ( multi-byte characters ).
//
int TTFontClass::Find_Text_VLength( HDC hdc, char *str, int width )
{
int curlen = 0;
int lastlen = 0;
int lines = Get_Height();
char *letter = str;
bool make_dc = FALSE;
HDC localDC = hdc;
if ( *str == '\0' || str == NULL ) {
return( 0 );
}
//--------------------------------------------------------------------------
// If no DC was passed in, then we need to get one.
//--------------------------------------------------------------------------
if ( localDC == NULL ) {
return( 0 );
}
//==========================================================================
// Process languages EXCEPT Double-byte languages.
//==========================================================================
if( !(IS_LANGUAGE_DBCS( LanguageID ))) {
//-----------------------------------------------------------------------
// Get the pixel length of the string.
//-----------------------------------------------------------------------
curlen = String_Pixel_Width( localDC, str );
lines = 0;
//-----------------------------------------------------------------------
// If the string in longer than the width given, calculate the number of
// lines needed in pixels (height of string in pixels ).
//-----------------------------------------------------------------------
if ( curlen > width ) {
while( curlen > 0 ) {
if ( curlen > width ) {
curlen -= width;
} else {
curlen = 0;
}
lines += Get_Height();
}
} else {
lines = Get_Height();
}
//-----------------------------------------------------------------------
// Check for any newlines. Add one line per newline.
//-----------------------------------------------------------------------
letter = str;
while ( *letter ) {
if ( *letter == '\n') {
lines += Get_Height();
}
letter++;
}
} else {
//=======================================================================
// Process Double-Byte language text.
//=======================================================================
int i, n, wspc;
UINT c;
int fdbcs = IsFontDBCS();
lines = 0;
//-----------------------------------------------------------------------
// For each word...
//-----------------------------------------------------------------------
while ( n = nGetWord( letter, fdbcs )) {
//--------------------------------------------------------------------
// For each character in the word...
//--------------------------------------------------------------------
for ( c=0, wspc=0, curlen=0, i=0; i < n; i++ ) {
if ( c ) {
//--------------------------------------------------------------
// Double-byte character.
//--------------------------------------------------------------
c = ( c<<8 )|(UINT)(BYTE)letter[i];
curlen += Char_Pixel_Width( localDC, c ) + wspc;
c = 0;
wspc = 0;
} else if( fdbcs && IsDBCSLeadByte((BYTE)letter[i])) {
//--------------------------------------------------------------
// First half of a Double-byte character.
//--------------------------------------------------------------
c = (UINT)(BYTE)letter[i];
} else if((BYTE)letter[i] > ' ' ) {
//--------------------------------------------------------------
// Single-byte character.
//--------------------------------------------------------------
curlen += Char_Pixel_Width( localDC, (UINT)(BYTE)letter[i] ) + wspc;
wspc = 0;
} else if( letter[i] == ' ') {
//--------------------------------------------------------------
// Space character.
//--------------------------------------------------------------
wspc += Char_Pixel_Width( localDC, ' ' );
}
} // end-of-for
//--------------------------------------------------------------------
//
//--------------------------------------------------------------------
if( lastlen + curlen > width ) {
lines += Get_Height();
lastlen = 0;
}
//--------------------------------------------------------------------
// !!! If one block length bigger than available width,
// next line will be overflow. but never endless loop. !!!
//--------------------------------------------------------------------
lastlen += curlen + wspc;
//--------------------------------------------------------------------
//
//--------------------------------------------------------------------
if( letter[i] == '\n' ) {
lines += Get_Height();
lastlen = 0;
}
letter += n;
} // end-of-while
//-----------------------------------------------------------------------
// Left over, add a line.
//-----------------------------------------------------------------------
if( lastlen ) {
lines += Get_Height();
}
}
//--------------------------------------------------------------------------
// Return the number of lines.
//--------------------------------------------------------------------------
if ( !lines ) {
lines = Get_Height();
}
return( lines );
}
/***********************************************************************************************
* FontManagerClass::FontManagerClass -- Constructor for FontManager class. *
* *
* INPUT: none. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 03/26/1998 MML : Created. *
*=============================================================================================*/
FontManagerClass::FontManagerClass ( HDC hdc )
{
//--------------------------------------------------------------------------
// Open a DC to the BackBuffer.
//--------------------------------------------------------------------------
if ( hdc ) {
char szPath[ MAX_PATH ];
char szFile[ MAX_PATH ];
char szFacename[ MAX_PATH ];
char drive[ _MAX_DRIVE ];
char dir[ _MAX_DIR ];
bool b640X480 = false;
RECT rect; // Desktop Window ( used once ).
strcpy( szFile, "Arial.ttf" );
strcpy( szFacename, "Arial" );
strcpy( szPath, Args->Get_argv(0));
_splitpath( szPath, drive, dir, NULL, NULL );
_makepath( szPath, drive, dir, "Setup\\Setup", ".ini" );
GetPrivateProfileString( "Fonts", "Font", "Arial.tff", szFile, MAX_PATH, szPath );
GetPrivateProfileString( "Fonts", "Fontname", "Arial", szFacename, MAX_PATH, szPath );
//---------------------------------------------------------------------
// Use codepage set by Locomoto class.
//---------------------------------------------------------------------
UINT codepage = CodePage; // GetACP();
GetClientRect( GetDesktopWindow(), &rect );
if( rect.right <= 640 ) {
b640X480 = TRUE;
}
Msg( __LINE__, __FILE__, "FontManagerClass -- szFile = %s, szFilename = %s.", szFile, szFacename );
//---------------------------------------------------------------------
// Create the True Type Fonts.
//
// Value Weight
// ____________________________
// FW_DONTCARE 0
// FW_THIN 100
// FW_EXTRALIGHT 200
// FW_ULTRALIGHT 200
// FW_LIGHT 300
// FW_NORMAL 400
// FW_REGULAR 400
// FW_MEDIUM 500
// FW_SEMIBOLD 600
// FW_DEMIBOLD 600
// FW_BOLD 700
// FW_EXTRABOLD 800
// FW_ULTRABOLD 800
// FW_HEAVY 900
// FW_BLACK 900
//---------------------------------------------------------------------
switch( LanguageID ) { // [OYO] Add this line if you wish to support another languages
//=================================================================
// JAPANESE
//=================================================================
case LANG_JAP: // [OYO] Use MS PGothic for Japanese Win9x
if( codepage == 932 ) {
strcpy( szFile, "MSGothic.ttc" );
strcpy( szFacename, "MS PGothic" );
TTButtonFontPtr = new TTFontClass( hdc, szFile, szFacename, 20, FW_NORMAL, SHIFTJIS_CHARSET );
TTButtonFontPtrSmall= new TTFontClass( hdc, szFile, szFacename, 12, FW_NORMAL, SHIFTJIS_CHARSET );
TTTextFontPtr = new TTFontClass( hdc, szFile, szFacename, 16, FW_MEDIUM, SHIFTJIS_CHARSET );
TTTextFontPtr640 = new TTFontClass( hdc, szFile, szFacename, 14, FW_MEDIUM, SHIFTJIS_CHARSET );
TTTextFontPtr800 = new TTFontClass( hdc, szFile, szFacename, 14, FW_MEDIUM, SHIFTJIS_CHARSET );
TTLicenseFontPtr = new TTFontClass( hdc, szFile, szFacename, 12, FW_NORMAL, SHIFTJIS_CHARSET );
}
break;
//=================================================================
// KOREAN
//=================================================================
case LANG_KOR: // [OYO] Use GulimChe for Korean Win9x
if ( codepage == 949 ) {
strcpy( szFile, "Gulim.tff" );
strcpy( szFacename, "Gulim" );
TTButtonFontPtr = new TTFontClass( hdc, szFile, szFacename, 20, FW_NORMAL, HANGEUL_CHARSET );
TTButtonFontPtrSmall= new TTFontClass( hdc, szFile, szFacename, 20, FW_NORMAL, HANGEUL_CHARSET );
TTTextFontPtr = new TTFontClass( hdc, szFile, szFacename, 16, FW_MEDIUM, HANGEUL_CHARSET );
TTTextFontPtr640 = new TTFontClass( hdc, szFile, szFacename, 14, FW_MEDIUM, HANGEUL_CHARSET );
TTTextFontPtr800 = new TTFontClass( hdc, szFile, szFacename, 14, FW_MEDIUM, HANGEUL_CHARSET );
TTLicenseFontPtr = new TTFontClass( hdc, szFile, szFacename, 12, FW_NORMAL, HANGEUL_CHARSET );
}
break;
//=================================================================
// CHINESE
//=================================================================
case LANG_CHI:
if ( codepage == 950 ) {
strcpy( szFile, "mingliu.ttc" );
strcpy( szFacename, "mingliu" );
TTButtonFontPtr = new TTFontClass( hdc, szFile, szFacename, 20, FW_NORMAL, CHINESEBIG5_CHARSET );
TTButtonFontPtrSmall= new TTFontClass( hdc, szFile, szFacename, 14, FW_NORMAL, CHINESEBIG5_CHARSET );
TTTextFontPtr = new TTFontClass( hdc, szFile, szFacename, 16, FW_MEDIUM, CHINESEBIG5_CHARSET );
TTTextFontPtr640 = new TTFontClass( hdc, szFile, szFacename, 14, FW_MEDIUM, CHINESEBIG5_CHARSET );
TTTextFontPtr800 = new TTFontClass( hdc, szFile, szFacename, 14, FW_MEDIUM, CHINESEBIG5_CHARSET );
TTLicenseFontPtr = new TTFontClass( hdc, szFile, szFacename, 12, FW_NORMAL, CHINESEBIG5_CHARSET );
}
break;
//=================================================================
// ENGLISH, FRENCH, GERMAN
//=================================================================
case LANG_GER:
case LANG_FRE:
case LANG_USA:
default:
TTButtonFontPtr = new TTFontClass( hdc, szFile, szFacename, 22, FW_SEMIBOLD, ANSI_CHARSET, 0, 0, 0, FALSE );
if( LANG_FRE == LanguageID ) {
TTButtonFontPtrSmall= new TTFontClass( hdc, szFile, szFacename, 20, FW_SEMIBOLD, ANSI_CHARSET, 0, 0, 0, FALSE );
} else {
TTButtonFontPtrSmall= new TTFontClass( hdc, szFile, szFacename, 22, FW_SEMIBOLD, ANSI_CHARSET, 0, 0, 0, FALSE );
}
TTTextFontPtr = new TTFontClass( hdc, szFile, szFacename, 16, FW_SEMIBOLD, ANSI_CHARSET, 0, 0, 0, FALSE );
TTTextFontPtr640 = new TTFontClass( hdc, szFile, szFacename, 14, FW_SEMIBOLD, ANSI_CHARSET, 0, 0, 0, FALSE );
TTTextFontPtr800 = new TTFontClass( hdc, szFile, szFacename, 14, FW_SEMIBOLD, ANSI_CHARSET, 0, 0, 0, FALSE );
TTLicenseFontPtr = new TTFontClass( hdc, szFile, szFacename, 12, FW_MEDIUM, ANSI_CHARSET, 0, 0, 0, FALSE );
break;
}
//----------------------------------------------------------------------
// If we fell through...
//----------------------------------------------------------------------
if( TTButtonFontPtr == NULL || TTTextFontPtr == NULL ) {
strcpy( szFile, "Arial.tff" );
strcpy( szFacename, "Arial" );
if( TTButtonFontPtr == NULL ) {
TTButtonFontPtr = new TTFontClass( hdc, szFile, szFacename, 22, FW_SEMIBOLD, ANSI_CHARSET, 0, 0, 0, FALSE );
}
if( TTButtonFontPtrSmall == NULL ) {
TTButtonFontPtrSmall= new TTFontClass( hdc, szFile, szFacename, 22, FW_SEMIBOLD, ANSI_CHARSET, 0, 0, 0, FALSE );
}
if( TTTextFontPtr == NULL ) {
TTTextFontPtr = new TTFontClass( hdc, szFile, szFacename, 16, FW_SEMIBOLD, ANSI_CHARSET, 0, 0, 0, FALSE );
}
if( TTTextFontPtr640 == NULL ) {
TTTextFontPtr640 = new TTFontClass( hdc, szFile, szFacename, 14, FW_SEMIBOLD, ANSI_CHARSET, 0, 0, 0, FALSE );
}
if( TTTextFontPtr800 == NULL ) {
TTTextFontPtr800 = new TTFontClass( hdc, szFile, szFacename, 14, FW_SEMIBOLD, ANSI_CHARSET, 0, 0, 0, FALSE );
}
if( TTLicenseFontPtr == NULL ) {
TTLicenseFontPtr = new TTFontClass( hdc, szFile, szFacename, 12, FW_MEDIUM, ANSI_CHARSET, 0, 0, 0, FALSE );
}
}
}
assert( TTTextFontPtr != NULL );
assert( TTTextFontPtr640 != NULL );
assert( TTTextFontPtr800 != NULL );
assert( TTButtonFontPtr != NULL );
assert( TTButtonFontPtrSmall != NULL );
assert( TTLicenseFontPtr != NULL );
}
/***********************************************************************************************
* FontManagerClass::~FontManagerClass -- Destructor for FontManager class. *
* *
* INPUT: none. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 03/26/1998 MML : Created. *
*=============================================================================================*/
FontManagerClass::~FontManagerClass ( void )
{
if ( TTButtonFontPtr != NULL ) {
delete TTButtonFontPtr;
TTButtonFontPtr = NULL;
}
if ( TTTextFontPtr != NULL ) {
delete TTTextFontPtr;
TTTextFontPtr = NULL;
}
}
/***********************************************************************************************
* Font_From_TPF -- Convert flags into a font pointer. *
* *
* This routine will examine the specified flags and return with a pointer to the font *
* that the flags represent. *
* *
* INPUT: flags -- The flags to convert into a font pointer. *
* *
* OUTPUT: Returns with a font pointer that matches the flags. *
* *
* WARNINGS: If no match could be found, a default font pointer is returned. *
* *
* HISTORY: *
* 05/26/1997 JLB : Created. *
*=============================================================================================*/
TTFontClass * Font_From_TPF ( TextPrintType flags )
{
TTFontClass *fontptr= NULL;
switch (flags & 0x000F) {
case TPF_BUTTON_FONT:
fontptr = TTButtonFontPtr;
break;
case TPF_TEXT_FONT:
fontptr = TTTextFontPtr;
break;
default:
fontptr = TTTextFontPtr;
break;
}
return( fontptr );
}
/************************************************************************************************
* Is_True_Type_Font -- Convert flags into a font pointer. *
* *
* This routine will examine the specified flags and return with a pointer to the font *
* that the flags represent. *
* *
* INPUT: flags -- The flags to convert into a font pointer. *
* *
* OUTPUT: Returns with a font pointer that matches the flags. *
* *
* WARNINGS: If no match could be found, a default font pointer is returned. *
* *
* HISTORY: *
* 05/26/1997 JLB : Created. *
*==============================================================================================*/
bool Is_True_Type_Font( TextPrintType flags )
{
if (( flags == TPF_BUTTON_FONT ) || ( flags == TPF_TEXT_FONT )) {
return TRUE;
} else {
return FALSE;
}
}
Reference in New Issue View Git Blame Copy Permalink