windows-server-2003/windows/feime/kor/ime2k/fecommon/common/cfont.cpp

//////////////////////////////////////////////////////////////////
// File     :	cfont.cpp
// Purpose  :	Font handling class source code.
//				Shared by each Applet.
//				You can compile/test this file. see main() function below.
// 
// Date     :	Thu Jul 01 12:20:34 1999
// Author   :	toshiak
//
// Copyright(c) 1995-1999, Microsoft Corp. All rights reserved
//////////////////////////////////////////////////////////////////
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#include <tchar.h>
#include "cfont.h"
#include "cutil.h"
#ifdef _TEST_CFONT
#include <stdio.h>
#endif //_TEST_CFONT

// Safe String
#define STRSAFE_NO_DEPRECATE
#include "strsafe.h"

//----------------------------------------------------------------
//structure define for internal 
//----------------------------------------------------------------
#define EFI_STOPIFFOUND		0x00000001
#define EFI_DONTENUMVERT	0x00010000

typedef struct tagENUMFONTINFOA {
	DWORD		dwFlag;
	BOOL		fFound;
	LOGFONTA	logFontIn;
	LOGFONTA	logFontOut;
}ENUMFONTINFOA, *LPENUMFONTINFOA;

typedef struct tagENUMFONTINFOW {
	DWORD		dwFlag;
	BOOL		fFound;
	LOGFONTW	logFontIn;
	LOGFONTW	logFontOut;
}ENUMFONTINFOW, *LPENUMFONTINFOW;

#ifdef UNICODE
#define ENUMFONTINFO	ENUMFONTINFOW
#define LPENUMFONTINFO	LPENUMFONTINFOW
#else
#define ENUMFONTINFO	ENUMFONTINFOA
#define LPENUMFONTINFO	LPENUMFONTINFOA
#endif

#ifdef UNDER_CE // Windows CE does not support EnumFontFamiliesEx
inline int EnumFontFamiliesEx(HDC hdc, LPLOGFONT lpLogfont, FONTENUMPROC lpEnumFontFamProc,
							  LPARAM lParam, DWORD)
{
	return ::EnumFontFamilies(hdc, lpLogfont->lfFaceName, lpEnumFontFamProc, lParam);
}

#ifndef ZeroMemory // Defined on sdk\inc\objbase.h under new source tree
#define ZeroMemory(dest, len) memset((dest),0,(len))
#endif
#define DEFAULT_GUI_FONT SYSTEM_FONT
#endif // UNDER_CE

//----------------------------------------------------------------
//
//	Public Method.
//
//----------------------------------------------------------------
//////////////////////////////////////////////////////////////////
// Function	:	CFont::CreateDefGUIFont
// Type		:	HFONT
// Purpose	:	Create(Copy) DEFAULT_GUI_FONT font Handle.
// Args		:	None
// Return	:	
// DATE		:	Wed Jun 30 18:33:15 1999
// Histroy	:	
//////////////////////////////////////////////////////////////////
HFONT
CFont::CreateDefGUIFont(VOID)
{
	HFONT hFont = (HFONT)::GetStockObject(DEFAULT_GUI_FONT);
	if(!hFont) {
		return NULL;
	}
#ifdef AWBOTH
	if(CUtil::IsWinNT()) {
		LOGFONTW lf;
		if(!::GetObjectW(hFont, sizeof(lf), &lf)) {
			return NULL;
		}
		return ::CreateFontIndirectW(&lf);
	}
#endif
	LOGFONT lf;
	if(!::GetObject(hFont, sizeof(lf), &lf)) {
		return NULL;
	}
	return ::CreateFontIndirect(&lf);
}

INT PointSize2LogPixel(INT pointSize)
{
	HWND hwnd = NULL;
	HDC hDC = ::GetDC(hwnd);
	INT dpi = ::GetDeviceCaps(hDC, LOGPIXELSY);
	::ReleaseDC(hwnd, hDC);
	return (pointSize * dpi)/72;
}

//////////////////////////////////////////////////////////////////
// Function	:	CFont::CreateGUIFontByCharSet
// Type		:	HFONT
// Purpose	:	Create GUI Font handle with specified characterset.
//				Font size is same with DEFAULT_GUI_FONT.
// Args		:	
//			:	LPTSTR	lpstrFontFace;	fontface string to search,
//										if this NULL, return first found
//										charset HFONT.
//			:	INT		charSet	
//			:	INT		poinstSize		Inclues VerticalFont or NOT (default is FALSE)
// Return	:	
// DATE		:	Wed Jun 30 18:37:54 1999
// Histroy	:	
//////////////////////////////////////////////////////////////////
HFONT
CFont::CreateGUIFontByNameCharSet(LPTSTR	lpstrFontFace,
								  INT		charSet,
								  INT		pointSize)
{
	LOGFONT lf, lfDef;
	//Get DEFAULT_GUI_FONT's LOGFONT data.
	if(!CFont::GetDefGUILogFont(&lfDef)) {
		return NULL;
	}
	//Search Specified charset font's LOGFONT data.
	if(!CFont::SearchLogFontByNameCharSet(&lf, lpstrFontFace, charSet, FALSE)) {
		return NULL;
	}
	lfDef.lfCharSet = lf.lfCharSet;
	if(pointSize > 0) {
		lfDef.lfHeight  = - PointSize2LogPixel(pointSize);
	}
	_tcscpy(lfDef.lfFaceName, lf.lfFaceName);
	return ::CreateFontIndirect(&lfDef);
}
#ifdef AWBOTH
HFONT
CFont::CreateGUIFontByNameCharSetW(LPWSTR	lpstrFontFace,
								   INT		charSet,
								   INT		pointSize)
{
	LOGFONTW lf, lfDef;
	//Get DEFAULT_GUI_FONT's LOGFONT data.
	if(!CFont::GetDefGUILogFontW(&lfDef)) {
		return NULL;
	}
	//Search Specified charset font's LOGFONT data.
	if(!CFont::SearchLogFontByNameCharSetW(&lf, lpstrFontFace, charSet, FALSE)) {
		return NULL;
	}

	lfDef.lfCharSet = lf.lfCharSet;
	if(pointSize > 0) {
		lfDef.lfHeight  = - PointSize2LogPixel(pointSize);
	}
	lfDef.lfWidth   = 0;
	wcscpy(lfDef.lfFaceName, lf.lfFaceName);
	return ::CreateFontIndirectW(&lfDef);
}
#endif //AWBOTH


//////////////////////////////////////////////////////////////////
// Function	:	CFont::IsFontExist
// Type		:	BOOL
// Purpose	:	Check specified FaceName & charSet font is Exit or NOT.
// Args		:	
//			:	LPTSTR	lpstrFontFace	
//			:	INT	charSet	
// Return	:	
// DATE		:	Thu Jul 22 23:00:54 1999
// Histroy	:	
//////////////////////////////////////////////////////////////////
BOOL
CFont::IsFontExist(LPTSTR lpstrFontFace, INT charSet)
{
	return CFont::SearchLogFontByNameCharSet(NULL,
											 lpstrFontFace,
											 charSet,
											 FALSE);
}

#ifdef AWBOTH
BOOL
CFont::IsFontExist(LPWSTR lpstrFontFace, INT charSet)
{
	return CFont::SearchLogFontByNameCharSetW(NULL,
											  lpstrFontFace,
											  charSet,
											  FALSE);
}
#endif //AWBOTH

//////////////////////////////////////////////////////////////////
// Function	:	CFont::GetFontNameByCharSet
// Type		:	BOOL
// Purpose	:	Serach & Get FontFace with Specified charSet
// Args		:	
//			:	INT	charSet	
//			:	LPTSTR	lpstrFontFace	
//			:	INT	cchMax	
// Return	:	
// DATE		:	Thu Jul 22 23:13:01 1999
// Histroy	:	
//////////////////////////////////////////////////////////////////
BOOL
CFont::GetFontNameByCharSet(INT		charSet,
							LPTSTR	lpstrFontFace,
							INT		cchMax)
{
	if(!lpstrFontFace) {
		return FALSE;
	}
	if(cchMax < LF_FACESIZE) {
		return FALSE;
	}

	LOGFONT lf;

	BOOL fRet = CFont::SearchLogFontByNameCharSet(&lf,
												  NULL,
												  charSet,
												  FALSE);
	if(fRet) {
		StringCchCopy(lpstrFontFace, cchMax, lf.lfFaceName);
	}
	return fRet;
}

#ifdef AWBOTH
BOOL
CFont::GetFontNameByCharSetW(INT	charSet,
							 LPWSTR	lpstrFontFace,
							 INT	cchMax)
{
	if(!lpstrFontFace) {
		return FALSE;
	}
	if(cchMax < LF_FACESIZE) {
		return FALSE;
	}

	LOGFONTW lf;

	BOOL fRet = CFont::SearchLogFontByNameCharSetW(&lf,
												  NULL,
												  charSet,
												  FALSE);
	if(fRet) {
		wcscpy(lpstrFontFace, lf.lfFaceName);
	}
	return fRet;
}
#endif


//////////////////////////////////////////////////////////////////
// Function	:	CFont::GetFontInfoByName
// Type		:	BOOL
// Purpose	:	
// Args		:	
//			:	LPTSTR	lpstrFontFace	
//			:	INT *	pCharSet	
//			:	INT *	pCodePage	
// Return	:	
// DATE		:	Fri Jul 23 02:48:29 1999
// Histroy	:	
//////////////////////////////////////////////////////////////////
BOOL
CFont::GetFontInfoByName(LPTSTR lpstrFontFace,
						 INT	*pCharSet,
						 INT	*pCodePage)
{
	LOGFONT lf;
	BOOL fRet = CFont::SearchLogFontByNameCharSet(&lf,
												  lpstrFontFace,
												  DEFAULT_CHARSET,
												  FALSE);
	if(!fRet) {
		return FALSE;
	}

	*pCharSet = (INT)lf.lfCharSet;
	CHARSETINFO info;
	if(::TranslateCharsetInfo((DWORD *)(DWORD_PTR)*pCharSet,
							  &info,
							  TCI_SRCCHARSET)) {
		*pCodePage = (INT)info.ciACP;
	}
	else { //failed
		*pCodePage = CP_ACP;
	}
	return 0;
}

#ifdef AWBOTH
BOOL
CFont::GetFontInfoByNameW(LPWSTR lpstrFontFace,
						  INT	  *pCharSet,
						  INT	  *pCodePage)
{
	LOGFONTW lf;
	BOOL fRet = CFont::SearchLogFontByNameCharSetW(&lf,
												   lpstrFontFace,
												   DEFAULT_CHARSET,
												   FALSE);
	if(!fRet) {
		return FALSE;
	}

	*pCharSet = (INT)lf.lfCharSet;
	CHARSETINFO info;
	if(::TranslateCharsetInfo((DWORD *)(DWORD_PTR)*pCharSet,
							  &info,
							  TCI_SRCCHARSET)) {
		*pCodePage = (INT)info.ciACP;
	}
	else { //failed
		*pCodePage = CP_ACP;
	}
	return 0;
}
#endif //AWBOTH

//----------------------------------------------------------------
//
// Private method.
//
//----------------------------------------------------------------
//////////////////////////////////////////////////////////////////
// Function	:	CFont::GetDefGUILogFont
// Type		:	BOOL
// Purpose	:	
// Args		:	LOGFONT *lpLF
// Return	:	
// DATE		:	Wed Jul 15 19:36:57 1998
// Histroy	:	
//////////////////////////////////////////////////////////////////
BOOL
CFont::GetDefGUILogFont(LOGFONT *lpLF)
{
	if(!lpLF) {
		return FALSE;
	}
	if(!::GetObject((HFONT)::GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONT), lpLF)) {
		return FALSE;
	}
	return TRUE;
}
////////////////////
//Unicode version.
////////////////////
#ifdef AWBOTH
BOOL
CFont::GetDefGUILogFontW(LOGFONTW *lpLF)
{
	if(!lpLF) {
		return FALSE;
	}
	if(!::GetObjectW((HFONT)::GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONTW), lpLF)) {
		return FALSE;
	}
	return TRUE;
}
#endif //AWBOTH


//////////////////////////////////////////////////////////////////
// Function	:	CFont::SearchLogFontByNameCharSet
// Type		:	BOOL
// Purpose	:	Search LOGFONT data with specified FaceName & charset.
//				If FaceName is not specified, return first find charset logfont.
// Args		:	
//			:	LOGFONT *	lpLF	
//			:	LPTSTR		lpstrFontFace	
//			:	INT			charSet	
//			:	BOOL		fIncVert
//								Inclues VerticalFont or NOT (default is FALSE)
// Return	:	
// DATE		:	Thu Jul 01 17:12:40 1999
// Histroy	:	
//////////////////////////////////////////////////////////////////
BOOL
CFont::SearchLogFontByNameCharSet(LOGFONT	*lpLF,
								  LPTSTR	lpstrFontFace,
								  INT		charSet,
								  BOOL		fIncVert)
{
	HWND hwndDC = NULL;
	HDC hDC = ::GetDC(hwndDC);
	if(!hDC) {
		return FALSE;
	}
	ENUMFONTINFO	enumFontInfo;
	LPENUMFONTINFO	lpEnumFontInfo = &enumFontInfo;

	::ZeroMemory(&enumFontInfo, sizeof(enumFontInfo));
	lpEnumFontInfo->logFontIn.lfCharSet = (BYTE)charSet; 
	if(lpstrFontFace) { 
		if(lstrlen(lpstrFontFace) < LF_FACESIZE) {
			_tcscpy(lpEnumFontInfo->logFontIn.lfFaceName, lpstrFontFace);
		}
	}
	lpEnumFontInfo->dwFlag	= EFI_STOPIFFOUND;
	lpEnumFontInfo->dwFlag |= fIncVert ? 0 : EFI_DONTENUMVERT;
	lpEnumFontInfo->fFound	= FALSE;
	::EnumFontFamiliesEx(hDC,
						 &lpEnumFontInfo->logFontIn,
						 (FONTENUMPROC)CFont::EnumFontFamiliesExProc,
						 (LPARAM)lpEnumFontInfo,
						 0);
	::ReleaseDC(hwndDC, hDC);

	if(lpEnumFontInfo->fFound) {
		if(lpLF) {
			*lpLF = lpEnumFontInfo->logFontOut;
		}
	}
	return lpEnumFontInfo->fFound;
}

#ifdef AWBOTH
BOOL
CFont::SearchLogFontByNameCharSetW(LOGFONTW *lpLF,
								   LPWSTR	lpstrFontFace,
								   INT		charSet,
								   BOOL		fIncVert)
{
	HWND hwndDC = NULL;
	HDC hDC = ::GetDC(hwndDC);
	if(!hDC) {
		return FALSE;
	}
	ENUMFONTINFOW	enumFontInfo;
	LPENUMFONTINFOW	lpEnumFontInfo = &enumFontInfo;

	::ZeroMemory(&enumFontInfo, sizeof(enumFontInfo));
	lpEnumFontInfo->logFontIn.lfCharSet = (BYTE)charSet; 
	if(lpstrFontFace) { 
		if(wcslen(lpstrFontFace) < LF_FACESIZE) {
			wcscpy(lpEnumFontInfo->logFontIn.lfFaceName, lpstrFontFace);
		}
	}
	lpEnumFontInfo->dwFlag	= EFI_STOPIFFOUND;
	lpEnumFontInfo->dwFlag |= fIncVert ? 0 : EFI_DONTENUMVERT;
	lpEnumFontInfo->fFound	= FALSE;

	::EnumFontFamiliesExW(hDC,
						  &lpEnumFontInfo->logFontIn,
						  (FONTENUMPROCW)CFont::EnumFontFamiliesExProcW,
						  (LPARAM)lpEnumFontInfo,
						  0);
	::ReleaseDC(hwndDC, hDC);

	if(lpEnumFontInfo->fFound) {
		if(lpLF) {
			*lpLF = lpEnumFontInfo->logFontOut;
		}
	}
	return lpEnumFontInfo->fFound;
}
#endif

//////////////////////////////////////////////////////////////////
// Function	:	CFont::EnumFontFamiliesExProc
// Type		:	INT	CALLBACK
// Purpose	:	
// Args		:	
//			:	ENUMLOGFONTEX *	lpElf
//			:	NEWTEXTMETRIC *	lpNtm
//			:	INT	iFontType	
//			:	LPARAM	lParam	
// Return	:	
// DATE		:	Thu Jul 01 15:17:56 1999
// Histroy	:	
//////////////////////////////////////////////////////////////////
INT CALLBACK
CFont::EnumFontFamiliesExProc(ENUMLOGFONTEX	*lpElf,
							  NEWTEXTMETRIC	*lpNtm,
							  INT			iFontType,
							  LPARAM		lParam)
{
	LPENUMFONTINFO	lpEnumFontInfo = (LPENUMFONTINFO)lParam;
	if(!lpEnumFontInfo) {
		return 0; //Do not continue;
	}

	if(lpEnumFontInfo->dwFlag & EFI_STOPIFFOUND) {
		if(lpEnumFontInfo->logFontIn.lfFaceName[0] == (TCHAR)0x00) {
			if(lpEnumFontInfo->logFontIn.lfCharSet == lpElf->elfLogFont.lfCharSet) {
				//----------------------------------------------------------------
				//if EFI_DONTENUMVERT is set, 
				//Do skip vertical font enumulation.
				//----------------------------------------------------------------
				if( (lpEnumFontInfo->dwFlag & EFI_DONTENUMVERT) &&
					lpElf->elfLogFont.lfFaceName[0] == (TCHAR)'@') {
					return 1; //continue to enum.
				}
				//Found specified charSet's logfont
				lpEnumFontInfo->logFontOut = lpElf->elfLogFont;
				lpEnumFontInfo->fFound	   = TRUE;	
				return 0; //Do not coninue;
			}
		}
		else {
			if(lpEnumFontInfo->logFontIn.lfCharSet == lpElf->elfLogFont.lfCharSet &&
			   0 == _tcscmp(lpEnumFontInfo->logFontIn.lfFaceName, lpElf->elfLogFont.lfFaceName)) {
				//Found specified charSet's logfont
				lpEnumFontInfo->logFontOut = lpElf->elfLogFont;
				lpEnumFontInfo->fFound	   = TRUE;	
				return 0; //Do not coninue;
			}
		}
	}
	else {
#ifdef _TEST_CFONT
		extern LPTSTR GetCharset(int );
		_tprintf(TEXT("[%-24s] [%-20s][%s][%s][%s]\n"), 
				 lpElf->elfLogFont.lfFaceName,
				 GetCharset(lpElf->elfLogFont.lfCharSet),
				 lpElf->elfFullName,
				 lpElf->elfScript,
				 lpElf->elfStyle);
#endif
	}
	return 1;//continue to enum;
	UNREFERENCED_PARAMETER(lpNtm);
	UNREFERENCED_PARAMETER(iFontType);
}

#ifdef AWBOTH
INT CALLBACK
CFont::EnumFontFamiliesExProcW(ENUMLOGFONTEXW	*lpElf,
							   NEWTEXTMETRIC	*lpNtm,
							   INT				iFontType,
							   LPARAM			lParam)
{
	LPENUMFONTINFOW	lpEnumFontInfo = (LPENUMFONTINFOW)lParam;
	if(!lpEnumFontInfo) {
		return 0; //Do not continue;
	}

	if(lpEnumFontInfo->dwFlag & EFI_STOPIFFOUND) {
		if(lpEnumFontInfo->logFontIn.lfFaceName[0] == (WCHAR)0x00) {
			if(lpEnumFontInfo->logFontIn.lfCharSet == lpElf->elfLogFont.lfCharSet) {
				//----------------------------------------------------------------
				//if EFI_DONTENUMVERT is set, 
				//Do skip vertical font enumulation.
				//----------------------------------------------------------------
				if( (lpEnumFontInfo->dwFlag & EFI_DONTENUMVERT) &&
					lpElf->elfLogFont.lfFaceName[0] == (WCHAR)'@') {
					return 1; //continue to enum.
				}
				//Found specified charSet's logfont
				lpEnumFontInfo->logFontOut = lpElf->elfLogFont;
				lpEnumFontInfo->fFound	   = TRUE;
				return 0; //Do not coninue;
			}
		}
		else {
			if(lpEnumFontInfo->logFontIn.lfCharSet == lpElf->elfLogFont.lfCharSet &&
			   0 == wcscmp(lpEnumFontInfo->logFontIn.lfFaceName, lpElf->elfLogFont.lfFaceName)) {
				//Found specified charSet's logfont
				lpEnumFontInfo->logFontOut = lpElf->elfLogFont;
				lpEnumFontInfo->fFound	   = TRUE;
				return 0; //Do not coninue;
			}
		}
	}
	return 1;//continue to enum;
	UNREFERENCED_PARAMETER(lpNtm);
	UNREFERENCED_PARAMETER(iFontType);
}
#endif //AWBOTH




//----------------------------------------------------------------
//
// test program for cfontex.cpp 
//
// how to compile.	
// 1. for ANSI.	
//   cl cfontex.cpp -I../common -D_TEST_CFONT -link user32.lib advapi32.lib gdi32.lib
// 2. for Ansi&Wide both
//   cl cfontex.cpp -I../common -DAWBOTH -D_TEST_CFONT -link user32.lib advapi32.lib gdi32.lib
// 2. for Unicode.
//   cl cfontex.cpp -I../common -DUNICODE -D_UNICODE -D_TEST_CFONT -link user32.lib advapi32.lib gdi32.lib
//----------------------------------------------------------------
#ifdef _TEST_CFONT
#if defined(UNICODE) ||  defined(_UNICODE)
#define DEFSTR(a)	{a, L ## #a}
#else
#define DEFSTR(a)	{a, #a}
#endif
typedef struct tagIDSTR {
	INT id;
	TCHAR *p;
}IDSTR;

IDSTR idstr[]= {
	DEFSTR(ANSI_CHARSET),
	DEFSTR(DEFAULT_CHARSET),
	DEFSTR(SYMBOL_CHARSET),
	DEFSTR(SHIFTJIS_CHARSET),
	DEFSTR(HANGEUL_CHARSET),
	DEFSTR(HANGUL_CHARSET),
	DEFSTR(GB2312_CHARSET),
	DEFSTR(CHINESEBIG5_CHARSET),
	DEFSTR(OEM_CHARSET),
	DEFSTR(JOHAB_CHARSET),
	DEFSTR(HEBREW_CHARSET),
	DEFSTR(ARABIC_CHARSET),
	DEFSTR(GREEK_CHARSET),
	DEFSTR(TURKISH_CHARSET),
	DEFSTR(VIETNAMESE_CHARSET),
	DEFSTR(THAI_CHARSET),
	DEFSTR(EASTEUROPE_CHARSET),
	DEFSTR(RUSSIAN_CHARSET),
	DEFSTR(MAC_CHARSET),
	DEFSTR(BALTIC_CHARSET),
};

#define ArrayCount(a)	sizeof(a)/sizeof(a[0])
LPTSTR GetCharset(INT charset)
{
	static TCHAR szbuf[256];
	int i;
	for( i = 0; i < ArrayCount(idstr); i++) {
		if(charset == idstr[i].id) {
			return idstr[i].p;
		}
	}
	wsprintf(szbuf, TEXT("Unknown Charset[0x%08x]"), charset);
	return szbuf;
}

VOID PrintLogFont(LOGFONT *lplf)
{
	_tprintf(TEXT("lfHeight        [%d]\n"), lplf->lfHeight);
	_tprintf(TEXT("lfWidth         [%d]\n"), lplf->lfWidth );
	_tprintf(TEXT("lfEscapement    [%d]\n"), lplf->lfEscapement);
	_tprintf(TEXT("lfOrientation   [%d]\n"), lplf->lfOrientation);
	_tprintf(TEXT("lfWeight        [%d]\n"), lplf->lfWeight);
	_tprintf(TEXT("lfItalic        [%d]\n"), lplf->lfItalic);
	_tprintf(TEXT("lfUnderline     [%d]\n"), lplf->lfUnderline);
	_tprintf(TEXT("lfStrikeOut     [%d]\n"), lplf->lfStrikeOut);
	_tprintf(TEXT("lfCharSet       [%d]\n"), lplf->lfCharSet);
	_tprintf(TEXT("lfOutPrecision  [%d]\n"), lplf->lfOutPrecision);
	_tprintf(TEXT("lfClipPrecision [%d]\n"), lplf->lfClipPrecision);
	_tprintf(TEXT("lfQuality       [%d]\n"), lplf->lfQuality);
	_tprintf(TEXT("lfPitchAndFamily[%d]\n"), lplf->lfPitchAndFamily);
	_tprintf(TEXT("lfFaceName      [%s]\n"), lplf->lfFaceName);
}


#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include <mbstring.h>
#include <mbctype.h>
#include <locale.h>
#include "cfont.h"
#include "cutil.h"
#include "cutil.cpp"
extern LPTSTR GetCharset(INT charset);
void main(void)
{
	_tsetlocale(LC_ALL, TEXT(".ACP"));
	HWND hwndDC = NULL;
	HDC hDC = ::GetDC(hwndDC);
	ENUMFONTINFO	enumFontInfo;
	LPENUMFONTINFO	lpEnumFontInfo = &enumFontInfo;

#if 0
	::ZeroMemory(&enumFontInfo, sizeof(enumFontInfo));
	lpEnumFontInfo->logFontIn.lfCharSet = (BYTE)DEFAULT_CHARSET;
	lpEnumFontInfo->dwFlag	= 0;
	_tprintf(TEXT("Enumlate All Font\n"));
	::EnumFontFamiliesEx(hDC,
						 &lpEnumFontInfo->logFontIn,
						 (FONTENUMPROC)CFont::EnumFontFamiliesExProc,
						 (LPARAM)lpEnumFontInfo,
						 0);

	::ZeroMemory(&enumFontInfo, sizeof(enumFontInfo));
	lpEnumFontInfo->logFontIn.lfCharSet = ANSI_CHARSET;
	lpEnumFontInfo->dwFlag	= 0;
	_tprintf(TEXT("Enumulate ANSI_CHARSET font\n"));
	::EnumFontFamiliesEx(hDC,
						 &lpEnumFontInfo->logFontIn,
						 (FONTENUMPROC)CFont::EnumFontFamiliesExProc,
						 (LPARAM)lpEnumFontInfo,
						 0);
	_tprintf(TEXT("Enumulate SHIFTJIS_CHARSET font\n"));
	::ZeroMemory(&enumFontInfo, sizeof(enumFontInfo));
	lpEnumFontInfo->logFontIn.lfCharSet = SHIFTJIS_CHARSET;
	lpEnumFontInfo->dwFlag	= 0;
	::EnumFontFamiliesEx(hDC,
						 &lpEnumFontInfo->logFontIn,
						 (FONTENUMPROC)CFont::EnumFontFamiliesExProc,
						 (LPARAM)lpEnumFontInfo,
						 0);

	::ReleaseDC(hwndDC, hDC);
#endif

	LOGFONT lf;
	BOOL fRet;
	static LPTSTR fontNameList[]= { TEXT("MS Mincho"),
									TEXT("MS Gothic"),
									TEXT("MS UI Gothic"),
									TEXT("�l�r ����"),
									TEXT("�l�r �o����"),
									TEXT("�l�r �S�V�b�N"),
									TEXT("�l�r �o�S�V�b�N")};

	CFont::GetDefGUILogFont(&lf);
	_tprintf(TEXT("DEFAULT_GUI_FONT LOGFONT\n"));
	PrintLogFont(&lf);

	int i;
	for(i = 0; i < sizeof(fontNameList)/sizeof(fontNameList[0]); i++) {
		fRet = CFont::SearchLogFontByNameCharSet(&lf,
												 fontNameList[i],
												 SHIFTJIS_CHARSET);
		_tprintf(TEXT("Search Font [%-20s] %s\n"),
				 fontNameList[i],
				 fRet ? TEXT("FOUND") : TEXT("NOT FOUND"));
		if(fRet) {
			PrintLogFont(&lf);
			HFONT hFont = CFont::CreateGUIFontByNameCharSet(fontNameList[i],
															SHIFTJIS_CHARSET, FALSE);
			LOGFONT lfNew;
			::GetObject(hFont, sizeof(lfNew), &lfNew);
			PrintLogFont(&lfNew);
		}
	}
}

#endif //_TEST_CFONT