1

/* $Id$ */

     2

     3

/** @file fontcache.cpp Cache for characters from fonts. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "spritecache.h"

     9

#include "fontcache.h"

    10

#include "spriteloader/spriteloader.hpp"

    11

#include "blitter/factory.hpp"

    12

#include "gfx_func.h"

    13

#include "core/alloc_func.hpp"

    14

#include "core/math_func.hpp"

    15

    16

#include "table/sprites.h"

    17

#include "table/control_codes.h"

    18

    19

#ifdef WITH_FREETYPE

    20

#include <ft2build.h>

    21

#include FT_FREETYPE_H

    22

#include FT_GLYPH_H

    23

    24

#ifdef WITH_FONTCONFIG

    25

#include <fontconfig/fontconfig.h>

    26

#endif

    27

    28

static FT_Library _library = NULL;

    29

static FT_Face _face_small = NULL;

    30

static FT_Face _face_medium = NULL;

    31

static FT_Face _face_large = NULL;

    32

    33

FreeTypeSettings _freetype;

    34

    35

enum {

    36

	FACE_COLOUR = 1,

    37

	SHADOW_COLOUR = 2,

    38

};

    39

    40

/** Get the font loaded into a Freetype face by using a font-name.

    41

 * If no appropiate font is found, the function returns an error */

    42

#ifdef WIN32

    43

#include <windows.h>

    44

#include <tchar.h>

    45

#include <shlobj.h> // SHGetFolderPath

    46

#include "win32.h"

    47

    48

/* Get the font file to be loaded into Freetype by looping the registry

    49

 * location where windows lists all installed fonts. Not very nice, will

    50

 * surely break if the registry path changes, but it works. Much better

    51

 * solution would be to use CreateFont, and extract the font data from it

    52

 * by GetFontData. The problem with this is that the font file needs to be

    53

 * kept in memory then until the font is no longer needed. This could mean

    54

 * an additional memory usage of 30MB (just for fonts!) when using an eastern

    55

 * font for all font sizes */

    56

#define FONT_DIR_NT "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts"

    57

#define FONT_DIR_9X "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Fonts"

    58

static FT_Error GetFontByFaceName(const char *font_name, FT_Face *face)

    59

{

    60

	FT_Error err = FT_Err_Cannot_Open_Resource;

    61

	HKEY hKey;

    62

	LONG ret;

    63

	TCHAR vbuffer[MAX_PATH], dbuffer[256];

    64

	TCHAR *font_namep;

    65

	char *font_path;

    66

	uint index;

    67

    68

	/* On windows NT (2000, NT3.5, XP, etc.) the fonts are stored in the

    69

	 * "Windows NT" key, on Windows 9x in the Windows key. To save us having

    70

	 * to retrieve the windows version, we'll just query both */

    71

	ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T(FONT_DIR_NT), 0, KEY_READ, &hKey);

    72

	if (ret != ERROR_SUCCESS) ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T(FONT_DIR_9X), 0, KEY_READ, &hKey);

    73

    74

	if (ret != ERROR_SUCCESS) {

    75

		DEBUG(freetype, 0, "Cannot open registry key HKLM\\SOFTWARE\\Microsoft\\Windows (NT)\\CurrentVersion\\Fonts");

    76

		return err;

    77

	}

    78

    79

	/* For Unicode we need some conversion between widechar and

    80

	 * normal char to match the data returned by RegEnumValue,

    81

	 * otherwise just use parameter */

    82

#if defined(UNICODE)

    83

	font_namep = MallocT<TCHAR>(MAX_PATH);

    84

	MB_TO_WIDE_BUFFER(font_name, font_namep, MAX_PATH * sizeof(TCHAR));

    85

#else

    86

	font_namep = (char*)font_name; // only cast because in unicode pointer is not const

    87

#endif

    88

    89

	for (index = 0;; index++) {

    90

		TCHAR *s;

    91

		DWORD vbuflen = lengthof(vbuffer);

    92

		DWORD dbuflen = lengthof(dbuffer);

    93

    94

		ret = RegEnumValue(hKey, index, vbuffer, &vbuflen, NULL, NULL, (byte*)dbuffer, &dbuflen);

    95

		if (ret != ERROR_SUCCESS) goto registry_no_font_found;

    96

    97

		/* The font names in the registry are of the following 3 forms:

    98

		 * - ADMUI3.fon

    99

		 * - Book Antiqua Bold (TrueType)

   100

		 * - Batang & BatangChe & Gungsuh & GungsuhChe (TrueType)

   101

		 * We will strip the font-type '()' if any and work with the font name

   102

		 * itself, which must match exactly; if...

   103

		 * TTC files, font files which contain more than one font are seperated

   104

		 * byt '&'. Our best bet will be to do substr match for the fontname

   105

		 * and then let FreeType figure out which index to load */

   106

		s = _tcschr(vbuffer, _T('('));

   107

		if (s != NULL) s[-1] = '\0';

   108

   109

		if (_tcschr(vbuffer, _T('&')) == NULL) {

   110

			if (_tcsicmp(vbuffer, font_namep) == 0) break;

   111

		} else {

   112

			if (_tcsstr(vbuffer, font_namep) != NULL) break;

   113

		}

   114

	}

   115

   116

	if (!SUCCEEDED(SHGetFolderPath(NULL, CSIDL_FONTS, NULL, SHGFP_TYPE_CURRENT, vbuffer))) {

   117

		DEBUG(freetype, 0, "SHGetFolderPath cannot return fonts directory");

   118

		goto folder_error;

   119

	}

   120

   121

	/* Some fonts are contained in .ttc files, TrueType Collection fonts. These

   122

	 * contain multiple fonts inside this single file. GetFontData however

   123

	 * returns the whole file, so we need to check each font inside to get the

   124

	 * proper font.

   125

	 * Also note that FreeType does not support UNICODE filesnames! */

   126

#if defined(UNICODE)

   127

	/* We need a cast here back from wide because FreeType doesn't support

   128

	 * widechar filenames. Just use the buffer we allocated before for the

   129

	 * font_name search */

   130

	font_path = (char*)font_namep;

   131

	WIDE_TO_MB_BUFFER(vbuffer, font_path, MAX_PATH * sizeof(TCHAR));

   132

#else

   133

	font_path = vbuffer;

   134

#endif

   135

   136

	ttd_strlcat(font_path, "\\", MAX_PATH * sizeof(TCHAR));

   137

	ttd_strlcat(font_path, WIDE_TO_MB(dbuffer), MAX_PATH * sizeof(TCHAR));

   138

	index = 0;

   139

	do {

   140

		err = FT_New_Face(_library, font_path, index, face);

   141

		if (err != FT_Err_Ok) break;

   142

   143

		if (strncasecmp(font_name, (*face)->family_name, strlen((*face)->family_name)) == 0) break;

   144

		err = FT_Err_Cannot_Open_Resource;

   145

   146

	} while ((FT_Long)++index != (*face)->num_faces);

   147

   148

   149

folder_error:

   150

registry_no_font_found:

   151

#if defined(UNICODE)

   152

	free(font_namep);

   153

#endif

   154

	RegCloseKey(hKey);

   155

	return err;

   156

}

   157

   158

   159

struct EFCParam {

   160

	FreeTypeSettings *settings;

   161

	LOCALESIGNATURE  locale;

   162

};

   163

   164

static int CALLBACK EnumFontCallback(const ENUMLOGFONTEX *logfont, const NEWTEXTMETRICEX *metric, DWORD type, LPARAM lParam)

   165

{

   166

	EFCParam *info = (EFCParam *)lParam;

   167

   168

	/* Only use TrueType fonts */

   169

	if (!(type & TRUETYPE_FONTTYPE)) return 1;

   170

	/* Don't use SYMBOL fonts */

   171

	if (logfont->elfLogFont.lfCharSet == SYMBOL_CHARSET) return 1;

   172

   173

	/* The font has to have at least one of the supported locales to be usable. */

   174

	if ((metric->ntmFontSig.fsCsb[0] & info->locale.lsCsbSupported[0]) == 0 && (metric->ntmFontSig.fsCsb[1] & info->locale.lsCsbSupported[1]) == 0) {

   175

		/* On win9x metric->ntmFontSig seems to contain garbage. */

   176

		FONTSIGNATURE fs;

   177

		memset(&fs, 0, sizeof(fs));

   178

		HFONT font = CreateFontIndirect(&logfont->elfLogFont);

   179

		if (font != NULL) {

   180

			HDC dc = GetDC(NULL);

   181

			HGDIOBJ oldfont = SelectObject(dc, font);

   182

			GetTextCharsetInfo(dc, &fs, 0);

   183

			SelectObject(dc, oldfont);

   184

			ReleaseDC(NULL, dc);

   185

			DeleteObject(font);

   186

		}

   187

		if ((fs.fsCsb[0] & info->locale.lsCsbSupported[0]) == 0 && (fs.fsCsb[1] & info->locale.lsCsbSupported[1]) == 0) return 1;

   188

	}

   189

   190

	const char *font_name = WIDE_TO_MB((const TCHAR*)logfont->elfFullName);

   191

	DEBUG(freetype, 1, "Fallback font: %s", font_name);

   192

   193

	strecpy(info->settings->small_font,  font_name, lastof(info->settings->small_font));

   194

	strecpy(info->settings->medium_font, font_name, lastof(info->settings->medium_font));

   195

	strecpy(info->settings->large_font,  font_name, lastof(info->settings->large_font));

   196

	return 0; // stop enumerating

   197

}

   198

   199

bool SetFallbackFont(FreeTypeSettings *settings, const char *language_isocode, int winlangid)

   200

{

   201

	EFCParam langInfo;

   202

	if (GetLocaleInfo(MAKELCID(winlangid, SORT_DEFAULT), LOCALE_FONTSIGNATURE, (LPTSTR)&langInfo.locale, sizeof(langInfo.locale) / sizeof(TCHAR)) == 0) {

   203

		/* Invalid langid or some other mysterious error, can't determine fallback font. */

   204

		DEBUG(freetype, 1, "Can't get locale info for fallback font (langid=0x%x)", winlangid);

   205

		return false;

   206

	}

   207

	langInfo.settings = settings;

   208

   209

	LOGFONT font;

   210

	/* Enumerate all fonts. */

   211

	font.lfCharSet = DEFAULT_CHARSET;

   212

	font.lfFaceName[0] = '\0';

   213

	font.lfPitchAndFamily = 0;

   214

   215

	HDC dc = GetDC(NULL);

   216

	int ret = EnumFontFamiliesEx(dc, &font, (FONTENUMPROC)&EnumFontCallback, (LPARAM)&langInfo, 0);

   217

	ReleaseDC(NULL, dc);

   218

	return ret == 0;

   219

}

   220

   221

#elif defined(WITH_FONTCONFIG)

   222

static FT_Error GetFontByFaceName(const char *font_name, FT_Face *face)

   223

{

   224

	FT_Error err = FT_Err_Cannot_Open_Resource;

   225

   226

	if (!FcInit()) {

   227

		ShowInfoF("Unable to load font configuration");

   228

	} else {

   229

		FcPattern *match;

   230

		FcPattern *pat;

   231

		FcFontSet *fs;

   232

		FcResult  result;

   233

		char *font_style;

   234

		char *font_family;

   235

   236

		/* Split & strip the font's style */

   237

		font_family = strdup(font_name);

   238

		font_style = strchr(font_family, ',');

   239

		if (font_style != NULL) {

   240

			font_style[0] = '\0';

   241

			font_style++;

   242

			while (*font_style == ' ' || *font_style == '\t') font_style++;

   243

		}

   244

   245

		/* Resolve the name and populate the information structure */

   246

		pat = FcNameParse((FcChar8*)font_family);

   247

		if (font_style != NULL) FcPatternAddString(pat, FC_STYLE, (FcChar8*)font_style);

   248

		FcConfigSubstitute(0, pat, FcMatchPattern);

   249

		FcDefaultSubstitute(pat);

   250

		fs = FcFontSetCreate();

   251

		match = FcFontMatch(0, pat, &result);

   252

   253

		if (fs != NULL && match != NULL) {

   254

			int i;

   255

			FcChar8 *family;

   256

			FcChar8 *style;

   257

			FcChar8 *file;

   258

			FcFontSetAdd(fs, match);

   259

   260

			for (i = 0; err != FT_Err_Ok && i < fs->nfont; i++) {

   261

				/* Try the new filename */

   262

				if (FcPatternGetString(fs->fonts[i], FC_FILE,   0, &file)   == FcResultMatch &&

   263

						FcPatternGetString(fs->fonts[i], FC_FAMILY, 0, &family) == FcResultMatch &&

   264

						FcPatternGetString(fs->fonts[i], FC_STYLE,  0, &style)  == FcResultMatch) {

   265

   266

					/* The correct style? */

   267

					if (font_style != NULL && strcasecmp(font_style, (char*)style) != 0) continue;

   268

   269

					/* Font config takes the best shot, which, if the family name is spelled

   270

					* wrongly a 'random' font, so check whether the family name is the

   271

					* same as the supplied name */

   272

					if (strcasecmp(font_family, (char*)family) == 0) {

   273

						err = FT_New_Face(_library, (char *)file, 0, face);

   274

					}

   275

				}

   276

			}

   277

		}

   278

   279

		free(font_family);

   280

		FcPatternDestroy(pat);

   281

		FcFontSetDestroy(fs);

   282

		FcFini();

   283

	}

   284

   285

	return err;

   286

}

   287

   288

bool SetFallbackFont(FreeTypeSettings *settings, const char *language_isocode, int winlangid)

   289

{

   290

	if (!FcInit()) return false;

   291

   292

	bool ret = false;

   293

   294

	/* Fontconfig doesn't handle full language isocodes, only the part

   295

	 * before the _ of e.g. en_GB is used, so "remove" everything after

   296

	 * the _. */

   297

	char lang[16];

   298

	strecpy(lang, language_isocode, lastof(lang));

   299

	char *split = strchr(lang, '_');

   300

	if (split != NULL) *split = '\0';

   301

   302

	FcPattern *pat;

   303

	FcPattern *match;

   304

	FcResult result;

   305

	FcChar8 *file;

   306

	FcFontSet *fs;

   307

	FcValue val;

   308

	val.type = FcTypeString;

   309

	val.u.s = (FcChar8*)lang;

   310

   311

	/* First create a pattern to match the wanted language */

   312

	pat = FcPatternCreate();

   313

	/* And fill it with the language and other defaults */

   314

	if (pat == NULL ||

   315

			!FcPatternAdd(pat, "lang", val, false) ||

   316

			!FcConfigSubstitute(0, pat, FcMatchPattern)) {

   317

		goto error_pattern;

   318

	}

   319

   320

	FcDefaultSubstitute(pat);

   321

   322

	/* The create a font set and match that */

   323

	match = FcFontMatch(0, pat, &result);

   324

   325

	if (match == NULL) {

   326

		goto error_pattern;

   327

	}

   328

   329

	/* Find all fonts that do match */

   330

	fs = FcFontSetCreate();

   331

	FcFontSetAdd(fs, match);

   332

   333

	/* And take the first, if it exists */

   334

	if (fs->nfont <= 0 || FcPatternGetString(fs->fonts[0], FC_FILE, 0, &file)) {

   335

		goto error_fontset;

   336

	}

   337

   338

	strecpy(settings->small_font,  (const char*)file, lastof(settings->small_font));

   339

	strecpy(settings->medium_font, (const char*)file, lastof(settings->medium_font));

   340

	strecpy(settings->large_font,  (const char*)file, lastof(settings->large_font));

   341

   342

	ret = true;

   343

   344

error_fontset:

   345

	FcFontSetDestroy(fs);

   346

error_pattern:

   347

	if (pat != NULL) FcPatternDestroy(pat);

   348

	FcFini();

   349

	return ret;

   350

}

   351

   352

#else /* without WITH_FONTCONFIG */

   353

FT_Error GetFontByFaceName(const char *font_name, FT_Face *face) {return FT_Err_Cannot_Open_Resource;}

   354

bool SetFallbackFont(FreeTypeSettings *settings, const char *language_isocode, int winlangid) { return false; }

   355

#endif /* WITH_FONTCONFIG */

   356

   357

/**

   358

 * Loads the freetype font.

   359

 * First type to load the fontname as if it were a path. If that fails,

   360

 * try to resolve the filename of the font using fontconfig, where the

   361

 * format is 'font family name' or 'font family name, font style'.

   362

 */

   363

static void LoadFreeTypeFont(const char *font_name, FT_Face *face, const char *type)

   364

{

   365

	FT_Error error;

   366

   367

	if (StrEmpty(font_name)) return;

   368

   369

	error = FT_New_Face(_library, font_name, 0, face);

   370

   371

	if (error != FT_Err_Ok) error = GetFontByFaceName(font_name, face);

   372

   373

	if (error == FT_Err_Ok) {

   374

		DEBUG(freetype, 2, "Requested '%s', using '%s %s'", font_name, (*face)->family_name, (*face)->style_name);

   375

   376

		/* Attempt to select the unicode character map */

   377

		error = FT_Select_Charmap(*face, ft_encoding_unicode);

   378

		if (error == FT_Err_Ok) return; // Success

   379

   380

		if (error == FT_Err_Invalid_CharMap_Handle) {

   381

			/* Try to pick a different character map instead. We default to

   382

			 * the first map, but platform_id 0 encoding_id 0 should also

   383

			 * be unicode (strange system...) */

   384

			FT_CharMap found = (*face)->charmaps[0];

   385

			int i;

   386

   387

			for (i = 0; i < (*face)->num_charmaps; i++) {

   388

				FT_CharMap charmap = (*face)->charmaps[i];

   389

				if (charmap->platform_id == 0 && charmap->encoding_id == 0) {

   390

					found = charmap;

   391

				}

   392

			}

   393

   394

			if (found != NULL) {

   395

				error = FT_Set_Charmap(*face, found);

   396

				if (error == FT_Err_Ok) return;

   397

			}

   398

		}

   399

	}

   400

   401

	FT_Done_Face(*face);

   402

	*face = NULL;

   403

   404

	ShowInfoF("Unable to use '%s' for %s font, FreeType reported error 0x%X, using sprite font instead", font_name, type, error);

   405

}

   406

   407

   408

void InitFreeType()

   409

{

   410

	if (StrEmpty(_freetype.small_font) && StrEmpty(_freetype.medium_font) && StrEmpty(_freetype.large_font)) {

   411

		DEBUG(freetype, 1, "No font faces specified, using sprite fonts instead");

   412

		return;

   413

	}

   414

   415

	if (FT_Init_FreeType(&_library) != FT_Err_Ok) {

   416

		ShowInfoF("Unable to initialize FreeType, using sprite fonts instead");

   417

		return;

   418

	}

   419

   420

	DEBUG(freetype, 2, "Initialized");

   421

   422

	/* Load each font */

   423

	LoadFreeTypeFont(_freetype.small_font,  &_face_small,  "small");

   424

	LoadFreeTypeFont(_freetype.medium_font, &_face_medium, "medium");

   425

	LoadFreeTypeFont(_freetype.large_font,  &_face_large,  "large");

   426

   427

	/* Set each font size */

   428

	if (_face_small  != NULL) FT_Set_Pixel_Sizes(_face_small,  0, _freetype.small_size);

   429

	if (_face_medium != NULL) FT_Set_Pixel_Sizes(_face_medium, 0, _freetype.medium_size);

   430

	if (_face_large  != NULL) FT_Set_Pixel_Sizes(_face_large,  0, _freetype.large_size);

   431

}

   432

   433

static void ResetGlyphCache();

   434

   435

/**

   436

 * Unload a face and set it to NULL.

   437

 * @param face the face to unload

   438

 */

   439

static void UnloadFace(FT_Face *face)

   440

{

   441

	if (*face == NULL) return;

   442

   443

	FT_Done_Face(*face);

   444

	*face = NULL;

   445

}

   446

   447

/**

   448

 * Free everything allocated w.r.t. fonts.

   449

 */

   450

void UninitFreeType()

   451

{

   452

	ResetGlyphCache();

   453

   454

	UnloadFace(&_face_small);

   455

	UnloadFace(&_face_medium);

   456

	UnloadFace(&_face_large);

   457

   458

	FT_Done_FreeType(_library);

   459

	_library = NULL;

   460

}

   461

   462

   463

static FT_Face GetFontFace(FontSize size)

   464

{

   465

	switch (size) {

   466

		default: NOT_REACHED();

   467

		case FS_NORMAL: return _face_medium;

   468

		case FS_SMALL:  return _face_small;

   469

		case FS_LARGE:  return _face_large;

   470

	}

   471

}

   472

   473

   474

struct GlyphEntry {

   475

	Sprite *sprite;

   476

	byte width;

   477

};

   478

   479

   480

/* The glyph cache. This is structured to reduce memory consumption.

   481

 * 1) There is a 'segment' table for each font size.

   482

 * 2) Each segment table is a discrete block of characters.

   483

 * 3) Each block contains 256 (aligned) characters sequential characters.

   484

 *

   485

 * The cache is accessed in the following way:

   486

 * For character 0x0041  ('A'): _glyph_ptr[FS_NORMAL][0x00][0x41]

   487

 * For character 0x20AC (Euro): _glyph_ptr[FS_NORMAL][0x20][0xAC]

   488

 *

   489

 * Currently only 256 segments are allocated, "limiting" us to 65536 characters.

   490

 * This can be simply changed in the two functions Get & SetGlyphPtr.

   491

 */

   492

static GlyphEntry **_glyph_ptr[FS_END];

   493

   494

/** Clear the complete cache */

   495

static void ResetGlyphCache()

   496

{

   497

	for (int i = 0; i < FS_END; i++) {

   498