Cool_Tools/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-12-18 19:35:52 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
09cb3a54ed
winamp/Src/Wasabi/api/font/font.cpp
Jef 20d28e80a5 Initial community commit
2024-09-24 14:54:57 +02:00

637 lines
21 KiB
C++
Raw Blame History

#include "precomp.h"
// ============================================================================================================================================================
// Font abstract class + statics to install TT fonts and Bitmap fonts
// ============================================================================================================================================================
#include <api/font/font.h>
#include <api/font/bitmapfont.h>
#include <bfc/parse/pathparse.h>
#ifdef WASABI_COMPILE_SKIN
#include <api/skin/skin.h>
#include <api/skin/skinparse.h>
#endif
#include <tataki/canvas/ifc_canvas.h>
#include <api/wnd/fontdef.h>
#ifdef WASABI_COMPILE_FONT
#include <api/service/svcs/svc_font.h>
//#include "services/svc_fontmaker.h"
#endif
#ifdef WASABI_API_CONFIG
#include <api/config/options.h>
#include <api/config/items/attrint.h>
#include <api/config/items/attrstr.h>
#include <api/config/items/attrbool.h>
#endif
#include <api/memmgr/api_memmgr.h>
#include <api/font/FontSvcEnum.h>
extern _bool cfg_options_usefontmapper;
extern _string cfg_options_ttfoverridefont;
extern _int cfg_options_defaultfontscale;
PtrList<svc_font> Font::fontlist;
PtrList<FontDef> Font::fontdefs;
void Font::init()
{
#ifdef WASABI_API_CONFIG
Wasabi::Std::setDefaultFont(cfg_options_defaultfont.getValue());
Wasabi::Std::setDefaultFontScale(cfg_options_defaultfontscale.getValueAsInt());
#endif
}
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
void Font::dispatchTextOut(ifc_canvas *c, int style, int x, int y, int w, int h, const wchar_t *txt)
{
int isoverride = 0;
if (WASABI_API_APP->main_isShuttingDown()) return;
int size = c->getTextSize();
svc_font *f = requestSkinFont(c->getTextFont(), &size);
ASSERT(f != NULL);
// After we get the font we want, check to see if it is bitmap.
// If bitmap fonts are disallowed, use the truetype override font.
if (f->isBitmap() && useTrueTypeOverride(txt))
{
int gotdefault=0;
svc_font *ttFont = requestSkinFont(getTrueTypeOverride(), &size, &gotdefault);
if (ttFont != NULL)
{
if (!gotdefault)
isoverride = 1;
f = ttFont;
}
}
if (isoverride)
{
double f = (double)getTrueTypeOverrideScale() / 100.0f;
size = (int)(size*f);
}
int bold = c->getTextBold();
int opaque = c->getTextOpaque();
int underline = c->getTextUnderline();
int italic = c->getTextItalic();
int align = c->getTextAlign();
int antialiased = c->getTextAntialias();
ARGB32 color = c->getTextColor();
ARGB32 bkcolor = c->getTextBkColor();
int xoffset=0, yoffset=0;
c->getOffsets(&xoffset, &yoffset);
/* if (!f->isBitmap() && _intVal(Main::enumRootCfgItem(0), "Force antialias on all TTF"))
antialiased = 1;*/
switch (style)
{
case WA_FONT_TEXTOUT_NORMAL:
f->textOut(c, x, y, txt, size, bold, opaque, underline, italic, color, bkcolor, xoffset, yoffset, antialiased);
break;
case WA_FONT_TEXTOUT_RECT:
f->textOut(c, x, y, w, h, txt, size, bold, opaque, underline, italic, align, color, bkcolor, xoffset, yoffset, antialiased);
break;
case WA_FONT_TEXTOUT_ELLIPSED:
f->textOutEllipsed(c, x, y, w, h, txt, size, bold, opaque, underline, italic, align, color, bkcolor, xoffset, yoffset, antialiased);
break;
case WA_FONT_TEXTOUT_WRAPPED:
f->textOutWrapped(c, x, y, w, h, txt, size, bold, opaque, underline, italic, align, color, bkcolor, xoffset, yoffset, antialiased);
break;
case WA_FONT_TEXTOUT_WRAPPEDPATHED:
f->textOutWrappedPathed(c, x, y, w, txt, size, bold, opaque, underline, italic, align, color, bkcolor, xoffset, yoffset, antialiased);
break;
case WA_FONT_TEXTOUT_CENTERED:
RECT r;
r.left = x;
r.top = y;
r.right = w;
r.bottom = h;
f->textOutCentered(c, &r, txt, size, bold, opaque, underline, italic, align, color, bkcolor, xoffset, yoffset, antialiased);
break;
}
}
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
int Font::dispatchGetInfo(ifc_canvas *c, const wchar_t *font, int infoid, const wchar_t *txt, int *w, int *h)
{
int isoverride = 0;
if (WASABI_API_APP->main_isShuttingDown()) return 0;
// mig: Let's not crash if we want to see how big a NULL pointer is.
if (txt == NULL) {
if ( infoid == WA_FONT_GETINFO_WIDTHHEIGHT ) {
if (w != NULL) {
*w = 0;
}
if (h != NULL) {
*h = 0;
}
}
return 0;
}
int size = c->getTextSize();
svc_font *f = requestSkinFont(font, &size);
ASSERT(f != NULL);
// After we get the font we want, check to see if it is bitmap.
// If bitmap fonts are disallowed, use the truetype override font.
if (f->isBitmap() && useTrueTypeOverride(txt))
{
int gotdefault = 0;
svc_font *ttFont = requestSkinFont(getTrueTypeOverride(), &size, &gotdefault);
if (ttFont != NULL)
{
if (!gotdefault)
isoverride = 1;
f = ttFont;
}
}
if (isoverride) {
double f = (double)getTrueTypeOverrideScale() / 100.0f;
size = (int)(size*f);
}
int bold = c->getTextBold();
int underline = c->getTextUnderline();
int italic = c->getTextItalic();
int antialiased = c->getTextAntialias();
switch (infoid) {
case WA_FONT_GETINFO_WIDTH:
return f->getTextWidth(c, txt, size, bold, underline, italic, antialiased);
case WA_FONT_GETINFO_HEIGHT:
return f->getTextHeight(c, txt, size, bold, underline, italic, antialiased);
case WA_FONT_GETINFO_WIDTHHEIGHT:
f->getTextExtent(c, txt, w, h, size, bold, underline, italic, antialiased);
return 0;
}
return 0;
}
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
// Install a truetype font from its filename and associate a script_id to it
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
svc_font *Font::installTrueTypeFont(const wchar_t *filename, const wchar_t *path, const wchar_t *id, int scriptid, int allowmapping, int isttfreload) {
if (!isttfreload)
{
FontDef *fd = new FontDef;
fd->filename = filename;
fd->path = path;
fd->id = id;
fd->scriptid = scriptid;
fd->isbitmap = 0;
fd->allowmapping = allowmapping;
fontdefs.addItem(fd);
}
StringW file;
OSFILETYPE ff=OPEN_FAILED;
if (wcschr(filename, ':'))
ff = WFOPEN(filename, WF_READONLY_BINARY);
if (ff == OPEN_FAILED)
{
file = StringPathCombine(path, filename);
ff = WFOPEN(file, WF_READONLY_BINARY);
}
#ifdef WASABI_COMPILE_SKIN
if (ff == OPEN_FAILED)
{
file = StringPathCombine(SkinParser::getXmlRootPath(), filename);
ff = WFOPEN(file, WF_READONLY_BINARY);
if (ff == OPEN_FAILED)
{
file = StringPathCombine(Skin::getDefaultSkinPath(), filename);
ff = WFOPEN(file, WF_READONLY_BINARY);
if (ff == OPEN_FAILED)
{
DebugString("Font not found %s\n", filename);
// todo: do something if still not found
}
}
}
#endif
if (ff == OPEN_FAILED) {
DebugString("Could not install font %s\n", filename);
return 0;
}
StringW fs = filename;
wchar_t *p = wcschr(fs.getNonConstVal(), '.');
if (p)
*p = 0;
PathParserW pp(fs);
fs = pp.getLastString();
svc_font *f = newTrueTypeFont();
if (f && f->addFontResource( ff, fs) )
{
f->setFontId(id);
f->setScriptId(scriptid);
fontlist.addItem(f);
} else {
DebugString("font.cpp ====== CAN'T LOAD FONT FILE.\n");
}
FCLOSE(ff);
return f;
}
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
// Uninstall all installed fonts
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
void Font::uninstallAll(int ttfreload) {
int i;
// delete all by hand
for (i = 0; i < fontlist.getNumItems(); i++) {
svc_font *f = fontlist.enumItem(i);
if (ttfreload && f->isBitmap()) continue;
deleteFont(f);
fontlist.removeByPos(i);
i--;
}
if (!ttfreload) fontdefs.deleteAll();
}
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
// Uninstall by scriptid
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
void Font::uninstallByScriptId(int scriptid) {
for (int i=0;i<fontlist.getNumItems();i++) {
svc_font *f = fontlist.enumItem(i);
if (f->getScriptId() == scriptid) {
fontlist.removeByPos(i);
deleteFont(f);
i--;
}
}
for (int i=0;i<fontdefs.getNumItems();i++) {
FontDef *fd = fontdefs.enumItem(i);
if (fd->scriptid == scriptid) {
fontdefs.removeByPos(i);
delete fd;
i--;
}
}
}
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
// Install a bitmap font and associates a script_id to it
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
void Font::installBitmapFont(const wchar_t *filename, const wchar_t *path, const wchar_t *id, int cw, int ch, int hs, int vs, int scriptid, int allowmapping)
{
FontDef *fd = new FontDef;
fd->filename = filename;
fd->path = path;
fd->id = id;
fd->scriptid = scriptid;
fd->isbitmap = 1;
fd->allowmapping = allowmapping;
fontdefs.addItem(fd);
BitmapFont *f = new BitmapFont;
f->setFontBitmap(filename, path);
f->setFontId(id);
f->setFontMetrics(cw, ch, hs, vs);
f->setScriptId(scriptid);
fontlist.addItem(f);
}
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
// Requests a Font* from its id
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
svc_font *Font::requestSkinFont(const wchar_t *id, int *size, int *gotdefault)
{
if (gotdefault) *gotdefault = 0;
int oldsize = size ? *size : -1;
const wchar_t *mapped_id = getFontMapping(id, size);
if (mapped_id != NULL)
id = mapped_id;
// First try to get a font by that id
foreach_reverse(fontlist)
const wchar_t *thisid = fontlist.getfor()->getFontId();
if (thisid && !WCSICMP(thisid, id))
return fontlist.getfor();
endfor
// if it wasnt found, try to load a wa-installed ttfont with this face name
foreach_reverse(fontlist)
const wchar_t *facename=fontlist.getfor()->getFaceName();
if (facename && !WCSICMP(facename, id)) return fontlist.getfor();
endfor
// not found, try to reload it front the list of fonts defined by the skin
foreach(fontdefs)
FontDef *fd = fontdefs.getfor();
if (!WCSICMP(fd->id, id))
{
if (!fd->isbitmap)
{
svc_font *f = installTrueTypeFont(fd->filename, fd->path, fd->id, fd->scriptid, fd->allowmapping, 1);
if (f) return f;
}
}
endfor;
/*
for (i=fontlist.getNumItems()-1;i>=0;i--) {
const char *thisid = fontlist.enumItem(i)->getFontId();
if (thisid && STRCASEEQL(thisid, "wasabi.font.ttf.default" ))
return fontlist.enumItem(i);
}
*/
// not found ? try to find it in the windows fonts directory
{
wchar_t *fp = WMALLOC(WA_MAX_PATH);
Wasabi::Std::getFontPath(WA_MAX_PATH, fp);
StringW file;
file.own(fp);
// FREE(fp); // benski> no need because we now own it
file.AppendPath(StringPrintfW(L"%s%s", id, WCSCASESTR(id, L".ttf") == NULL ? L".ttf":L""));
if (!WACCESS(file, 0))
{
svc_font *f = newTrueTypeFont();
f->setFontFace(id);
f->setFontId(id);
OSFILETYPE ff = WFOPEN(file, WF_READONLY_BINARY);
if (ff != OPEN_FAILED)
{
if (f->addFontResource(ff, id))
{
DebugStringW(L"font.cpp ====== FONT FOR ID=%s NOT FOUND. USING WIN FONT FILE:\n%s\n", id, file.getValue());
fontlist.addItem(f);
}
} else {
DebugStringW(L"font.cpp ====== FONT FOR ID=%s NOT FOUND. CANNOT OPEN WIN FONT FILE:\n%s\n", id, file.getValue());
delete f;
f = NULL;
}
return f;
}
}
// not found ? ask the Std:: interface for the folder and the
// default fontname (ie: one you know will always be in the OS)
svc_font *f = newTrueTypeFont();
if (f) {
if (gotdefault) *gotdefault = 1;
if (oldsize != -1 && size) {
*size = oldsize;
double f = (double)Wasabi::Std::getDefaultFontScale() / 100.0;
*size = (int)(*size*f);
}
// Query Std:: and build the path to the default font file.
wchar_t *fontPath = WMALLOC(WA_MAX_PATH);
Wasabi::Std::getFontPath(WA_MAX_PATH, fontPath);
wchar_t fontFile[WA_MAX_PATH] = {0};
Wasabi::Std::getDefaultFont(WA_MAX_PATH, fontFile);
StringW defaultFont;
defaultFont.own(fontPath);
defaultFont.AppendPath(fontFile);
// FREE(fontFile);
StringW fs = defaultFont;
wchar_t *p = wcschr(fs.getNonConstVal(), '.');
if (p) *p = 0;
PathParserW pp(fs);
fs = pp.getLastString();
f->setFontFace(fs);
f->setFontId(id);
// Open it and load it as the font resource.
OSFILETYPE ff = WFOPEN(defaultFont, WF_READONLY_BINARY);
if (ff != OPEN_FAILED) {
if (f->addFontResource(ff, fs))
{
DebugStringW(L"font.cpp ====== FONT FOR ID=%s NOT FOUND. USING DEFAULT FONT FILE:\n%s\n", id, defaultFont);
fontlist.addItem(f);
}
} else {
DebugStringW(L"font.cpp ====== FONT FOR ID=%s NOT FOUND. CANNOT OPEN FONT FILE:\n%s\n", id, defaultFont);
delete f;
f = NULL;
}
} else {
DebugString("font.cpp ====== CAN'T GET NEW FONT FILE.\n");
delete f;
f = NULL;
}
#ifdef _WIN32
if (f == NULL) {
// not found :((((( grab the default font data and use this, whatever it is
f = newTrueTypeFont();
if (f)
{
HDC dc = GetDC(GetDesktopWindow());
HDC dc2 = CreateCompatibleDC(dc);
SelectObject(dc2, GetStockObject(DEFAULT_GUI_FONT));
int datalen = GetFontData(dc2, 0, 0, NULL, 0);
if (datalen > 0) {
void *mem = WASABI_API_MEMMGR->sysMalloc(datalen+1); // freed by the service !!
ASSERT(mem != NULL);
GetFontData(dc2, 0, 0, mem, datalen);
f->setFontFace(id);
f->setFontId(id);
f->addFontResource2(mem, datalen, id);
ReleaseDC(GetDesktopWindow(), dc);
DeleteDC(dc2);
fontlist.addItem(f);
return f;
}
delete f;
f = NULL;
}
}
#else
#warning port me
#endif
if (f == NULL) {
// ok, NOW I'm getting pissed
wchar_t fp[WA_MAX_PATH] = {0};
Wasabi::Std::getFontPath(WA_MAX_PATH, fp);
#ifdef _WIN32
Wasabi::Std::messageBox(StringPrintfW(L"Fatal error trying to load truetype fonts.\n\nYou need arial.ttf at the very least, but it does not appear to be in %s", fp), L"Fatal Error", MB_ICONERROR);
#else
#warning port me
#endif
}
//if (f == NULL) DebugString("font.cpp ====== FALLBACK FOR FONT %s CANNOT BE FOUND IN OUR LISTS.\n",f->getFontId());
return f;
}
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
// Intelligently delete the font
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
void Font::deleteFont(svc_font *f)
{
if (f)
{
if (f->isBitmap())
{
delete static_cast<BitmapFont *>(f); // we delete our own bitmap fonts.
}
else
{
SvcEnum::release(f);
}
}
}
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
// Intelligently make a new truetype font from the service interfaces
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
svc_font *Font::newTrueTypeFont()
{
/*#ifdef WASABI_COMPILE_CONFIG
const GUID options_guid =
{ 0x280876cf, 0x48c0, 0x40bc, { 0x8e, 0x86, 0x73, 0xce, 0x6b, 0xb4, 0x62, 0xe5 } };
CfgItem *options = WASABI_API_CONFIG->config_getCfgItemByGuid(options_guid);
#endif*/
svc_font *retval = NULL;
const wchar_t *name = NULL;
#ifdef WASABI_COMPILE_CONFIG
//const wchar_t *attr = L"Font Renderer";
// First, try to find a font service that matches the attribute.
// if (options) {
// char buf[256]; // WHEEE for stack arrays
// if (options->getData(attr, buf, sizeof buf)) {
if (WASABI_API_SKIN->skin_getVersion() >= 1.3) // hardcode win32 renderer for v1.3+ skins
retval = FontSvcEnum(L"Win32 TextOut").getFirst();
else
retval = FontSvcEnum(cfg_options_fontrenderer.getValue()).getFirst();
#else
#ifndef WASABI_FONT_RENDERER
#error You need to define WASABI_FONT_RENDERER (ie: #define WASABI_FONT_RENDERER "Freetype")
#endif
retval = FontSvcEnum(WASABI_FONT_RENDERER).getFirst();
#endif
#ifdef WASABI_COMPILE_CONFIG
// }
// }
// If we can't find one, fallback and just take the first.
if (!retval)
{
retval = FontSvcEnum().getFirst();
if (retval != NULL)
name = retval->getFontSvcName();
}
// If we had to fallback, remember the fallback service in the attribute.
if (name/* && options*/)
{
//options->setData(attr, name);
cfg_options_fontrenderer.setValue(name);
}
#endif
return retval;
}
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
// Test whether to forbid bitmap fonts.
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
int Font::useTrueTypeOverride(const wchar_t *txt)
{
if (cfg_options_no7bitsttfoverride.getValueAsInt())
{
const wchar_t *p = (const wchar_t *)txt;
while (p && *p)
{
// TODO: benski> some characters above 127 can be handled by the bitmap fonts - it might be worth checking those explicitly
if (*p & 0xFF80)
break;
p++;
}
if (!*p) return 0;
}
#ifdef WASABI_COMPILE_CONFIG
/* // {280876CF-48C0-40bc-8E86-73CE6BB462E5}
const GUID options_guid =
{ 0x280876cf, 0x48c0, 0x40bc, { 0x8e, 0x86, 0x73, 0xce, 0x6b, 0xb4, 0x62, 0xe5 } };
return !_intVal(WASABI_API_CONFIG->config_getCfgItemByGuid(options_guid), "Use bitmap fonts (no international support)", 1);*/
return !cfg_options_allowbitmapfonts.getValueAsInt();
#else
return WASABI_FONT_TTFOVERRIDE;
#endif
}
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
// Get the font to be used to override bitmap fonts.
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
const wchar_t *Font::getTrueTypeOverride()
{
#ifdef WASABI_COMPILE_CONFIG
return cfg_options_ttfoverridefont.getValue();
#else
return L"Arial";
#warning TODO
#endif
}
int Font::getTrueTypeOverrideScale()
{
#ifdef WASABI_COMPILE_CONFIG
return cfg_options_ttfoverridescale.getValueAsInt();
#else
return 1;
#warning TODO
#endif
}
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
// Returns the font mapping for this font & skin, if font mapper is on and if there is a mapping, otherwise returns null
// -------------------------------------------------------------------------------------------------------------------------------------------------------------
const wchar_t *Font::getFontMapping(const wchar_t *id, int *size)
{
if (cfg_options_usefontmapper.getValueAsInt())
{
wchar_t t[256]=L"";
StringW tmp;
tmp.printf(L"Skin:%s/Font Mapping/%s",WASABI_API_SKIN->getSkinName(), id);
WASABI_API_CONFIG->getStringPrivate(tmp, t, 256, L"");
tmp.printf(L"Skin:%s/Font Mapping/%s_scale",WASABI_API_SKIN->getSkinName(), id);
int v = WASABI_API_CONFIG->getIntPrivate(tmp, -1);
if (!*t)
{
tmp.printf(L"Font Mapping/%s", id);
WASABI_API_CONFIG->getStringPrivate(tmp, t, 256, L"");
tmp.printf(L"Font Mapping/%s_scale", id);
v = WASABI_API_CONFIG->getIntPrivate(tmp, -1);
}
mapping = t;
if (mapping.isempty()) return NULL;
if (size != NULL)
{
if (v != -1)
{
double f = (double)v / 100.0;
*size = (int)((double)*size * f);
}
}
return mapping;
}
return NULL;
}
StringW Font::mapping;
Reference in New Issue View Git Blame Copy Permalink