static int CALLBACK EnumFamilyNamesW(
ENUMLOGFONTEXW *lpelfe, /* pointer to logical-font data */
NEWTEXTMETRICEX *lpntme, /* pointer to physical-font data */
int FontType, /* type of font */
LPARAM lParam ) /* application-defined data */
{
GdiFontMapInfo *fmi = (GdiFontMapInfo*)lParam;
JNIEnv *env = fmi->env;
jstring familyLC;
size_t slen;
LOGFONTW lfw;
/* Both Vista and XP return DEVICE_FONTTYPE for OTF fonts */
if (FontType != TRUETYPE_FONTTYPE && FontType != DEVICE_FONTTYPE) {
return 1;
}
/* wprintf(L"FAMILY=%s charset=%d FULL=%s\n", */
/* lpelfe->elfLogFont.lfFaceName, */
/* lpelfe->elfLogFont.lfCharSet, */
/* lpelfe->elfFullName); */
/* fflush(stdout); */
/* Windows lists fonts which have a vmtx (vertical metrics) table twice.
* Once using their normal name, and again preceded by '@'. These appear
* in font lists in some windows apps, such as wordpad. We don't want
* these so we skip any font where the first character is '@'
*/
if (lpelfe->elfLogFont.lfFaceName[0] == L'@') {
return 1;
}
slen = wcslen(lpelfe->elfLogFont.lfFaceName);
fmi->family = (*env)->NewString(env,lpelfe->elfLogFont.lfFaceName, (jsize)slen);
if (fmi->family == NULL) {
(*env)->ExceptionClear(env);
return 1;
}
familyLC = (*env)->CallObjectMethod(env, fmi->family,
fmi->toLowerCaseMID, fmi->locale);
/* check if already seen this family with a different charset */
if ((*env)->CallBooleanMethod(env,fmi->familyToFontListMap,
fmi->containsKeyMID, familyLC)) {
return 1;
}
fmi->list = (*env)->NewObject(env,
fmi->arrayListClass, fmi->arrayListCtr, 4);
if (fmi->list == NULL) {
(*env)->ExceptionClear(env);
return 1;
}
(*env)->CallObjectMethod(env, fmi->familyToFontListMap,
fmi->putMID, familyLC, fmi->list);
memset(&lfw, 0, sizeof(lfw));
wcscpy(lfw.lfFaceName, lpelfe->elfLogFont.lfFaceName);
lfw.lfCharSet = lpelfe->elfLogFont.lfCharSet;
EnumFontFamiliesExW(screenDC, &lfw,
(FONTENUMPROCW)EnumFontFacesInFamilyProcW,
lParam, 0L);
return 1;
}
static void gdi_get_font_metrics(LOGFONTW *lf, struct font_metrics *fm)
{
HDC hdc;
HFONT hfont;
NEWTEXTMETRICW ntm;
OUTLINETEXTMETRICW otm;
int ret;
hdc = CreateCompatibleDC(0);
/* it's the only way to get extended NEWTEXTMETRIC fields */
ret = EnumFontFamiliesExW(hdc, lf, font_enum_proc, (LPARAM)&ntm, 0);
ok(!ret, "EnumFontFamiliesExW failed to find %s\n", wine_dbgstr_w(lf->lfFaceName));
hfont = CreateFontIndirectW(lf);
SelectObject(hdc, hfont);
otm.otmSize = sizeof(otm);
ret = GetOutlineTextMetricsW(hdc, otm.otmSize, &otm);
ok(ret, "GetOutlineTextMetrics failed\n");
DeleteDC(hdc);
DeleteObject(hfont);
fm->lfHeight = -otm.otmTextMetrics.tmAscent;
fm->line_spacing = ntm.ntmCellHeight;
fm->font_size = (REAL)otm.otmTextMetrics.tmAscent;
fm->font_height = (REAL)fm->line_spacing * fm->font_size / (REAL)ntm.ntmSizeEM;
fm->em_height = ntm.ntmSizeEM;
fm->ascent = ntm.ntmSizeEM;
fm->descent = ntm.ntmCellHeight - ntm.ntmSizeEM;
}
// EnumFontName の Windows 環境依存処理を行う関数
extern int EnumFontName_Win( ENUMFONTDATA *EnumFontData, int CharSet )
{
HDC hdc ;
LOGFONTW LogFont ;
// デバイスコンテキストを取得
hdc = GetDC( NULL );
// 列挙開始
memset( &LogFont, 0, sizeof( LOGFONTW ) ) ;
LogFont.lfCharSet = ( BYTE )( CharSet < 0 ? DEFAULT_CHARSET : CharSetTable[ CharSet ] ) ;
if( EnumFontData->EnumFontName != NULL )
{
CL_strncpy( CODEPAGE_UTF16LE, ( char * )LogFont.lfFaceName, ( char * )EnumFontData->EnumFontName, 31 ) ;
}
else
{
LogFont.lfFaceName[0] = L'\0' ;
}
LogFont.lfPitchAndFamily = 0 ;
EnumFontFamiliesExW( hdc, &LogFont, ( FONTENUMPROCW )EnumFontFamExProcEx, ( LPARAM )EnumFontData, 0 ) ;
// デバイスコンテキストの解放
ReleaseDC( NULL, hdc ) ;
// 正常終了
return 0 ;
}
/* Initialize the font-list by enumeration all system fonts */
static
VOID
FillFontStyleComboList(HWND hwndCombo)
{
HDC hdc;
LOGFONTW lf;
/* FIXME: for fun, draw each font in its own style */
HFONT hFont = GetStockObject(DEFAULT_GUI_FONT);
SendMessageW(hwndCombo,
WM_SETFONT,
(WPARAM)hFont,
0);
ZeroMemory(&lf, sizeof(lf));
lf.lfCharSet = DEFAULT_CHARSET;
hdc = GetDC(hwndCombo);
/* store the list of fonts in the combo */
EnumFontFamiliesExW(hdc,
&lf,
(FONTENUMPROCW)EnumFontNames,
(LPARAM)hwndCombo,
0);
ReleaseDC(hwndCombo,
hdc);
SendMessageW(hwndCombo,
CB_SETCURSEL,
0,
0);
}
void
GDIFontFamily::FindStyleVariations()
{
if (mHasStyles)
return;
mHasStyles = PR_TRUE;
HDC hdc = GetDC(nsnull);
SetGraphicsMode(hdc, GM_ADVANCED);
LOGFONTW logFont;
memset(&logFont, 0, sizeof(LOGFONTW));
logFont.lfCharSet = DEFAULT_CHARSET;
logFont.lfPitchAndFamily = 0;
PRUint32 l = PR_MIN(mName.Length(), LF_FACESIZE - 1);
memcpy(logFont.lfFaceName,
nsPromiseFlatString(mName).get(),
l * sizeof(PRUnichar));
logFont.lfFaceName[l] = 0;
EnumFontFamiliesExW(hdc, &logFont,
(FONTENUMPROCW)GDIFontFamily::FamilyAddStylesProc,
(LPARAM)this, 0);
#ifdef PR_LOGGING
if (LOG_FONTLIST_ENABLED() && mAvailableFonts.Length() == 0) {
LOG_FONTLIST(("(fontlist) no styles available in family \"%s\"",
NS_ConvertUTF16toUTF8(mName).get()));
}
#endif
ReleaseDC(nsnull, hdc);
if (mIsBadUnderlineFamily)
SetBadUnderlineFonts();
}
GpStatus WINGDIPAPI GdipNewInstalledFontCollection(
GpFontCollection** fontCollection)
{
TRACE("(%p)\n",fontCollection);
if (!fontCollection)
return InvalidParameter;
if (installedFontCollection.count == 0)
{
HDC hdc;
LOGFONTW lfw;
hdc = GetDC(0);
lfw.lfCharSet = DEFAULT_CHARSET;
lfw.lfFaceName[0] = 0;
lfw.lfPitchAndFamily = 0;
if (!EnumFontFamiliesExW(hdc, &lfw, add_font_proc, (LPARAM)&installedFontCollection, 0))
{
free_installed_fonts();
ReleaseDC(0, hdc);
return OutOfMemory;
}
ReleaseDC(0, hdc);
}
*fontCollection = &installedFontCollection;
return Ok;
}
nsresult
gfxGDIFontList::InitFontList()
{
gfxFontCache *fc = gfxFontCache::GetCache();
if (fc)
fc->AgeAllGenerations();
// reset font lists
gfxPlatformFontList::InitFontList();
mFontSubstitutes.Clear();
mNonExistingFonts.Clear();
// iterate over available families
LOGFONTW logfont;
memset(&logfont, 0, sizeof(logfont));
logfont.lfCharSet = DEFAULT_CHARSET;
AutoDC hdc;
int result = EnumFontFamiliesExW(hdc.GetDC(), &logfont,
(FONTENUMPROCW)&EnumFontFamExProc,
0, 0);
GetFontSubstitutes();
StartLoader(kDelayBeforeLoadingFonts, kIntervalBetweenLoadingFonts);
return NS_OK;
}
BOOL CConfigAppearance::OnInitDialog()
{
CPropertyPage::OnInitDialog();
const CSettings *pSettings = theApp.GetSettings();
m_strFont = pSettings->Appearance.strFont; // // //
CDC *pDC = GetDC();
if (pDC != NULL) {
LOGFONTW LogFont = { }; // // //
LogFont.lfCharSet = ANSI_CHARSET;
EnumFontFamiliesExW(pDC->m_hDC, &LogFont, (FONTENUMPROC)EnumFontFamExProc, (LPARAM)this, 0);
ReleaseDC(pDC);
}
CComboBox *pFontSizeList = static_cast<CComboBox*>(GetDlgItem(IDC_FONT_SIZE));
CComboBox *pItemsBox = static_cast<CComboBox*>(GetDlgItem(IDC_COL_ITEM));
for (int i = 0; i < COLOR_ITEM_COUNT; ++i) {
pItemsBox->AddString(conv::to_wide(COLOR_ITEMS[i]).data());
}
pItemsBox->SelectString(0, conv::to_wide(COLOR_ITEMS[0]).data());
m_iSelectedItem = 0;
m_iColors[COL_BACKGROUND] = pSettings->Appearance.iColBackground;
m_iColors[COL_BACKGROUND_HILITE] = pSettings->Appearance.iColBackgroundHilite;
m_iColors[COL_BACKGROUND_HILITE2] = pSettings->Appearance.iColBackgroundHilite2;
m_iColors[COL_PATTERN_TEXT] = pSettings->Appearance.iColPatternText;
m_iColors[COL_PATTERN_TEXT_HILITE] = pSettings->Appearance.iColPatternTextHilite;
m_iColors[COL_PATTERN_TEXT_HILITE2] = pSettings->Appearance.iColPatternTextHilite2;
m_iColors[COL_PATTERN_INSTRUMENT] = pSettings->Appearance.iColPatternInstrument;
m_iColors[COL_PATTERN_VOLUME] = pSettings->Appearance.iColPatternVolume;
m_iColors[COL_PATTERN_EFF_NUM] = pSettings->Appearance.iColPatternEffect;
m_iColors[COL_SELECTION] = pSettings->Appearance.iColSelection;
m_iColors[COL_CURSOR] = pSettings->Appearance.iColCursor;
m_iColors[COL_CURRENT_ROW_NORMAL] = pSettings->Appearance.iColCurrentRowNormal; // // //
m_iColors[COL_CURRENT_ROW_EDIT] = pSettings->Appearance.iColCurrentRowEdit;
m_iColors[COL_CURRENT_ROW_PLAYING] = pSettings->Appearance.iColCurrentRowPlaying;
m_iFontSize = pSettings->Appearance.iFontSize; // // //
m_bPatternColors = pSettings->Appearance.bPatternColor; // // //
m_bDisplayFlats = pSettings->Appearance.bDisplayFlats; // // //
pItemsBox = static_cast<CComboBox*>(GetDlgItem(IDC_SCHEME));
for (auto *scheme : COLOR_SCHEMES)
pItemsBox->AddString(scheme->NAME);
for (int pt : FONT_SIZES) // // //
pFontSizeList->AddString(conv::to_wide(conv::from_int(pt)).data());
pFontSizeList->SetWindowTextW(conv::to_wide(conv::from_int(m_iFontSize)).data());
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
bool DoesFontExistW(CONST LOGFONTW *lplf)
{
if (!*lplf->lfFaceName)
return false;
HDC hdc = GetDC(NULL); // "If this value is NULL, GetDC retrieves the DC for the entire screen."
DWORD rv = 0;
EnumFontFamiliesExW(hdc, (LPLOGFONTW)lplf, &DoesFontExistWCallback, (LPARAM)&rv, 0);
ReleaseDC(NULL, hdc);
return rv != 0;
}
// This application exists to be connected to a console session while doing exactly nothing.
// This keeps a console session alive and doesn't interfere with tests or other hooks.
int __cdecl wmain(int /*argc*/, WCHAR* /*argv[]*/)
{
wil::unique_hdc hdc(CreateCompatibleDC(nullptr));
RETURN_LAST_ERROR_IF_NULL(hdc);
LOGFONTW LogFont = { 0 };
LogFont.lfCharSet = DEFAULT_CHARSET;
wcscpy_s(LogFont.lfFaceName, L"Terminal");
EnumFontFamiliesExW(hdc.get(), &LogFont, (FONTENUMPROC)FontEnumForV2Console, (LPARAM)hdc.get(), 0);
return 0;
}
BOOL DoLoadNames(void)
{
g_Names.clear();
LOGFONTW lf;
ZeroMemory(&lf, sizeof(lf));
lf.lfCharSet = DEFAULT_CHARSET;
HDC hDC = CreateCompatibleDC(NULL);
EnumFontFamiliesExW(hDC, &lf, (FONTENUMPROCW)EnumFontFamExProc, 0, 0);
DeleteDC(hDC);
return !g_Names.empty();
}
static void FX_EnumGdiFonts(CFX_FontDescriptors& fonts,
const FX_WCHAR* pwsFaceName,
FX_WCHAR wUnicode) {
HDC hDC = ::GetDC(nullptr);
LOGFONTW lfFind;
FXSYS_memset(&lfFind, 0, sizeof(lfFind));
lfFind.lfCharSet = DEFAULT_CHARSET;
if (pwsFaceName) {
FXSYS_wcsncpy(lfFind.lfFaceName, pwsFaceName, 31);
lfFind.lfFaceName[31] = 0;
}
EnumFontFamiliesExW(hDC, (LPLOGFONTW)&lfFind,
(FONTENUMPROCW)FX_GdiFontEnumProc, (LPARAM)&fonts, 0);
::ReleaseDC(nullptr, hDC);
}
FontFace *FontFace::CreateNative(const TextFormat &inFormat,double inScale)
{
//The height needs to be >=1, 0 causes the font mapper to use the default height
int height = (int)std::max(( 0.5 + inFormat.size*inScale ), 1.0);
LOGFONTW desc;
memset(&desc,0,sizeof(desc));
desc.lfHeight = -height;
//desc.lfWidth;
//desc.lfEscapement;
//desc.lfOrientation;
desc.lfWeight = inFormat.bold ? FW_BOLD : FW_NORMAL;
desc.lfItalic = inFormat.italic;
desc.lfUnderline = inFormat.underline;
//desc.lfStrikeOut;
desc.lfCharSet = DEFAULT_CHARSET;
desc.lfOutPrecision = OUT_RASTER_PRECIS;
desc.lfClipPrecision = CLIP_DEFAULT_PRECIS;
desc.lfQuality = ANTIALIASED_QUALITY;
desc.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
wcsncpy(desc.lfFaceName,inFormat.font(L"times").c_str(),LF_FACESIZE);
if (!sgFontDC)
{
sgFontDC = CreateCompatibleDC(0);
SetBkColor(sgFontDC, RGB(0,0,0));
SetTextColor(sgFontDC, RGB(255,255,255));
SetTextAlign( sgFontDC, TA_TOP );
}
// Check to see if it is there....
int bad = EnumFontFamiliesExW(sgFontDC, &desc, MyEnumFontFunc, 0, 0 );
if (bad)
{
return 0;
}
HFONT hfont = CreateFontIndirectW( &desc );
if (!hfont)
return 0;
return new GDIFont(hfont,height);
}
/*****************************************************************************
* GdipPrivateAddMemoryFont [GDIPLUS.@]
*/
GpStatus WINGDIPAPI GdipPrivateAddMemoryFont(GpFontCollection* fontCollection,
GDIPCONST void* memory, INT length)
{
WCHAR buf[32], *name;
DWORD count = 0;
HANDLE font;
TRACE("%p, %p, %d\n", fontCollection, memory, length);
if (!fontCollection || !memory || !length)
return InvalidParameter;
name = load_ttf_name_id(memory, length, NAME_ID_FULL_FONT_NAME, buf, sizeof(buf)/sizeof(*buf));
if (!name)
return OutOfMemory;
font = AddFontMemResourceEx((void*)memory, length, NULL, &count);
TRACE("%s: %p/%u\n", debugstr_w(name), font, count);
if (!font || !count)
return InvalidParameter;
if (count)
{
HDC hdc;
LOGFONTW lfw;
hdc = GetDC(0);
lfw.lfCharSet = DEFAULT_CHARSET;
lstrcpyW(lfw.lfFaceName, name);
lfw.lfPitchAndFamily = 0;
if (!EnumFontFamiliesExW(hdc, &lfw, add_font_proc, (LPARAM)fontCollection, 0))
{
ReleaseDC(0, hdc);
return OutOfMemory;
}
ReleaseDC(0, hdc);
}
return Ok;
}
bool AP_Win32Toolbar_FontCombo::populate(void)
{
// clear anything that's already there
m_vecContents.clear();
m_vecFontCharSet.clear();
seenFonts.clear();
// populate the vector
HWND hwnd = NULL;
HDC hdc = GetDC(hwnd) ;
LOGFONTW lf;
lf.lfCharSet=DEFAULT_CHARSET;
*lf.lfFaceName=0;
lf.lfPitchAndFamily=0;
EnumFontFamiliesExW(hdc, &lf, (FONTENUMPROCW) AP_Win32Toolbar_FontCombo::_EnumFontsProc, (LONG_PTR) this, 0) ;
ReleaseDC(hwnd, hdc) ;
seenFonts.clear();
return true;
}
static int DifferentFamily(wchar_t *family, wchar_t* fullName) {
LOGFONTW lfw;
CheckFamilyInfo info;
/* If fullName can't be stored in the struct, assume correct family */
if (wcslen((LPWSTR)fullName) >= LF_FACESIZE) {
return 0;
}
memset(&info, 0, sizeof(CheckFamilyInfo));
info.family = family;
info.fullName = fullName;
info.isDifferent = 0;
memset(&lfw, 0, sizeof(lfw));
wcscpy(lfw.lfFaceName, fullName);
lfw.lfCharSet = DEFAULT_CHARSET;
EnumFontFamiliesExW(GetDC(NULL), &lfw,
(FONTENUMPROCW)CheckFontFamilyProcW,
(LPARAM)(&info), 0L);
return info.isDifferent;
}
/* Obtain all the fontname -> filename mappings.
* This is called once and the results returned to Java code which can
* use it for lookups to reduce or avoid the need to search font files.
*/
JNIEXPORT void JNICALL
Java_sun_font_FontManager_populateFontFileNameMap
(JNIEnv *env, jclass obj, jobject fontToFileMap,
jobject fontToFamilyMap, jobject familyToFontListMap, jobject locale)
{
#define MAX_BUFFER (FILENAME_MAX+1)
const wchar_t wname[MAX_BUFFER];
const char cname[MAX_BUFFER];
const char data[MAX_BUFFER];
DWORD type;
LONG ret;
HKEY hkeyFonts;
DWORD dwNameSize;
DWORD dwDataValueSize;
DWORD nval;
LPCSTR fontKeyName;
DWORD dwNumValues, dwMaxValueNameLen, dwMaxValueDataLen;
DWORD numValues = 0;
jclass classID;
jmethodID putMID;
GdiFontMapInfo fmi;
/* Check we were passed all the maps we need, and do lookup of
* methods for JNI up-calls
*/
if (fontToFileMap == NULL ||
fontToFamilyMap == NULL ||
familyToFontListMap == NULL) {
return;
}
classID = (*env)->FindClass(env, "java/util/HashMap");
if (classID == NULL) {
return;
}
putMID = (*env)->GetMethodID(env, classID, "put",
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
if (putMID == NULL) {
return;
}
fmi.env = env;
fmi.fontToFamilyMap = fontToFamilyMap;
fmi.familyToFontListMap = familyToFontListMap;
fmi.putMID = putMID;
fmi.locale = locale;
fmi.containsKeyMID = (*env)->GetMethodID(env, classID, "containsKey",
"(Ljava/lang/Object;)Z");
if (fmi.containsKeyMID == NULL) {
return;
}
fmi.arrayListClass = (*env)->FindClass(env, "java/util/ArrayList");
if (fmi.arrayListClass == NULL) {
return;
}
fmi.arrayListCtr = (*env)->GetMethodID(env, fmi.arrayListClass,
"<init>", "(I)V");
if (fmi.arrayListCtr == NULL) {
return;
}
fmi.addMID = (*env)->GetMethodID(env, fmi.arrayListClass,
"add", "(Ljava/lang/Object;)Z");
if (fmi.addMID == NULL) {
return;
}
classID = (*env)->FindClass(env, "java/lang/String");
if (classID == NULL) {
return;
}
fmi.toLowerCaseMID =
(*env)->GetMethodID(env, classID, "toLowerCase",
"(Ljava/util/Locale;)Ljava/lang/String;");
if (fmi.toLowerCaseMID == NULL) {
return;
}
/* Enumerate fonts via GDI to build maps of fonts and families */
if (IS_NT) {
LOGFONTW lfw;
memset(&lfw, 0, sizeof(lfw));
lfw.lfCharSet = DEFAULT_CHARSET; /* all charsets */
wcscpy(lfw.lfFaceName, L""); /* one face per family (CHECK) */
EnumFontFamiliesExW(GetDC(NULL), &lfw,
(FONTENUMPROCW)EnumFamilyNamesW,
(LPARAM)(&fmi), 0L);
} else {
LOGFONT lfa;
memset(&lfa, 0, sizeof(lfa));
lfa.lfCharSet = DEFAULT_CHARSET; /* all charsets */
strcpy(lfa.lfFaceName, ""); /* one face per family */
ret = EnumFontFamiliesExA(GetDC(NULL), &lfa,
(FONTENUMPROCA)EnumFamilyNamesA,
(LPARAM)(&fmi), 0L);
}
/* Use the windows registry to map font names to files */
fontKeyName = (IS_NT) ? FONTKEY_NT : FONTKEY_WIN;
ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
fontKeyName, 0L, KEY_READ, &hkeyFonts);
if (ret != ERROR_SUCCESS) {
return;
}
if (IS_NT) {
ret = RegQueryInfoKeyW(hkeyFonts, NULL, NULL, NULL, NULL, NULL, NULL,
&dwNumValues, &dwMaxValueNameLen,
&dwMaxValueDataLen, NULL, NULL);
} else {
ret = RegQueryInfoKeyA(hkeyFonts, NULL, NULL, NULL, NULL, NULL, NULL,
&dwNumValues, &dwMaxValueNameLen,
&dwMaxValueDataLen, NULL, NULL);
}
if (ret != ERROR_SUCCESS ||
dwMaxValueNameLen >= MAX_BUFFER ||
dwMaxValueDataLen >= MAX_BUFFER) {
RegCloseKey(hkeyFonts);
return;
}
for (nval = 0; nval < dwNumValues; nval++ ) {
dwNameSize = MAX_BUFFER;
dwDataValueSize = MAX_BUFFER;
if (IS_NT) {
ret = RegEnumValueW(hkeyFonts, nval, (LPWSTR)wname, &dwNameSize,
NULL, &type, (LPBYTE)data, &dwDataValueSize);
} else {
ret = RegEnumValueA(hkeyFonts, nval, (LPSTR)cname, &dwNameSize,
NULL, &type, (LPBYTE)data, &dwDataValueSize);
}
if (ret != ERROR_SUCCESS) {
break;
}
if (type != REG_SZ) { /* REG_SZ means a null-terminated string */
continue;
}
if (IS_NT) {
if (!RegistryToBaseTTNameW((LPWSTR)wname) ) {
continue; /* not a TT font... */
}
registerFontW(&fmi, fontToFileMap, (LPWSTR)wname, (LPWSTR)data);
} else {
if (!RegistryToBaseTTNameA(cname) ) {
continue; /* not a TT font... */
}
registerFontA(&fmi, fontToFileMap, cname, (LPCSTR)data);
}
}
RegCloseKey(hkeyFonts);
}
