/* * Microsoft Confidential * Copyright (C) Microsoft Corporation 1991 * All Rights Reserved. * * * PIFFNT.C * User interface dialogs for GROUP_FNT * * History: * Created 04-Jan-1993 1:10pm by Jeff Parsons * Changed 05-May-1993 5:10pm by Raymond Chen -- New Chicago-look preview * Changed 12-Aug-1993 4:14pm by Raymond Chen -- Remove font inc and dec * * All font dialog code taken from font*.c in vmdosapp, 01-Apr-93 */ #include "shellprv.h" #pragma hdrstop #define REGSTR_MSDOSEMU_DISPLAYPARAMS TEXT("DisplayParams") #define REGSTR_PATH_MSDOSEMU "Software\\Microsoft\\Windows\\CurrentVersion\\MS-DOS Emulation" const TCHAR szWndPreviewClass[] = TEXT("WOAWinPreview"); const TCHAR szFontPreviewClass[] = TEXT("WOAFontPreview"); // The preview strings for bilingual dosbox. // We'll load this from our resource that will be properly // localized. We'll give up if it fails and use above sample // instead. UINT cxScreen, cyScreen, dyChar, dyItem; // Macro definitions that handle codepages // #define OEMCharsetFromCP(cp) \ ((cp)==CP_JPN? SHIFTJIS_CHARSET : ((cp)==CP_WANSUNG? HANGEUL_CHARSET : OEM_CHARSET)) /* * Font cache information. Note that this cache, being in PIFMGR, * is now global, which will make support for per-VM font files/faces * more problematic, if we even decide that's an interesting feature. * */ DWORD bpfdiStart[2] = { 0 }; /* strage for the offset to cache */ UINT cfdiCache[2]; /* # used entries in fdi cache */ UINT cfdiCacheActual[2]; /* Total # entries in fdi cache */ LPVOID lpCache = NULL; /* * Owner-draw list box information. * */ HBITMAP hbmFont; /* Handle to "TrueType" logo */ DWORD dwTimeCheck; COLORREF clrChecksum; HCURSOR hcursorWait; #define MAXDIMENSTRING 80 /* * Initial font heights for TT fonts * * This is read from an INI file, so it must remain writeable. * * We don't try generating TT fonts below 12pt by default because * they just look crappy. Frosting setup will put a different * table into place because Lucida Console looks good down to 4pt. * * On NT, Lucida Console is installed be default, though. * * The Frosting table is * 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 22 */ WORD rgwInitialTtHeights[] = { 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 22 }; /* * rgpnlPenalties -- Initialize penalty array to default values */ INT rgpnlPenalties[] = { 5000, 1000, 0, 1000, 5000, 1000, 0, 1000, 1 }; POINT ptNonAspectMin = { -1, -1 }; // Context-sensitive help ids const static DWORD rgdwHelp[] = { IDC_FONTGRP, IDH_COMM_GROUPBOX, IDC_RASTERFONTS, IDH_DOS_AVAIL_FONTS, IDC_TTFONTS, IDH_DOS_AVAIL_FONTS, IDC_BOTHFONTS, IDH_DOS_AVAIL_FONTS, IDC_FONTSIZELBL, IDH_DOS_FONT_SIZE, IDC_FONTSIZE, IDH_DOS_FONT_SIZE, IDC_WNDPREVIEWLBL, IDH_DOS_FONT_WINDOW_PREVIEW, IDC_FONTPREVIEWLBL, IDH_DOS_FONT_FONT_PREVIEW, IDC_WNDPREVIEW, IDH_DOS_FONT_WINDOW_PREVIEW, IDC_FONTPREVIEW, IDH_DOS_FONT_FONT_PREVIEW, IDC_REALMODEDISABLE, IDH_DOS_REALMODEPROPS, 0, 0 }; BOOL_PTR CALLBACK DlgFntProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) { PFNTINFO pfi = (PFNTINFO)GetWindowLongPtr(hDlg, DWLP_USER); switch (uMsg) { case WM_INITDIALOG: // allocate dialog instance data if (NULL != (pfi = (PFNTINFO)LocalAlloc(LPTR, sizeof(FNTINFO)))) { pfi->ppl = (PPROPLINK)((LPPROPSHEETPAGE)lParam)->lParam; SetWindowLongPtr(hDlg, DWLP_USER, (LPARAM)pfi); InitFntDlg(hDlg, pfi); break; } else { EndDialog(hDlg, FALSE); // fail the dialog create } break; case WM_DESTROY: // free any allocations/resources inside the pfi first! if (pfi) { if (pfi->hFontPreview) { DeleteObject(pfi->hFontPreview); pfi->hFontPreview = NULL; } // ok, NOW we can free the pfi EVAL(LocalFree(pfi) == NULL); SetWindowLongPtr(hDlg, DWLP_USER, 0); } break; HELP_CASES(rgdwHelp) // Handle help messages case WM_COMMAND: if (LOWORD(lParam) == 0) break; // message not from a control switch (LOWORD(wParam)) { case IDC_RASTERFONTS: case IDC_TTFONTS: case IDC_BOTHFONTS: /* * Rebuild the font list based on the user's selection of * which fonts to include/exclude. */ pfi->fntProposed.flFnt &= ~FNT_BOTHFONTS; pfi->fntProposed.flFnt |= FNTFLAGSFROMID(wParam); CreateFontList(GetDlgItem(hDlg, IDC_FONTSIZE), TRUE, &pfi->fntProposed); PreviewUpdate(GetDlgItem(hDlg, IDC_FONTSIZE), pfi); if (HIWORD(wParam) == BN_CLICKED) SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM)hDlg, 0L); return FALSE; case IDC_FONTSIZE: if (HIWORD(wParam) == LBN_SELCHANGE) { PreviewUpdate(GetDlgItem(hDlg, IDC_FONTSIZE), pfi); SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM)hDlg, 0L); return TRUE; } if (HIWORD(wParam) == LBN_DBLCLK) ApplyFntDlg(hDlg, pfi); return FALSE; } break; case WM_NOTIFY: switch (((NMHDR *)lParam)->code) { case PSN_SETACTIVE: AdjustRealModeControls(pfi->ppl, hDlg); break; case PSN_KILLACTIVE: // This gives the current page a chance to validate itself // SetWindowLong(hDlg, DWL_MSGRESULT, ValidFntDlg(hDlg, pfi)); break; case PSN_APPLY: // This happens on OK.... ApplyFntDlg(hDlg, pfi); break; case PSN_RESET: // This happens on Cancel.... break; } break; /* * For WM_MEASUREITEM and WM_DRAWITEM, since there is only one * owner-draw list box in the entire dialog box, we don't have * to do a GetDlgItem to figure out who he is. */ case WM_MEASUREITEM: // measure the owner draw listbox MeasureItemFontList((LPMEASUREITEMSTRUCT)lParam); break; case WM_DRAWITEM: DrawItemFontList(TRUE, (LPDRAWITEMSTRUCT)lParam); break; case WM_SYSCOLORCHANGE: UpdateTTBitmap(); break; default: return FALSE; // return 0 when not processing } return TRUE; } /** InitFntDlg * * Create the list of appropriate fonts. * * This routine is broken out of FontDlgProc because it chew * up lots of stack for the message buffer, and we don't want to * eat that much stack on every entry to FontDlgProc. * * Note that we must defer CreateFontList until WM_INITDIALOG * time because it is not until then that we have a list box that * we can shove the data into. */ void InitFntDlg(HWND hDlg, register PFNTINFO pfi) { HWND hwndList; /* The listbox of fonts */ PPROPLINK ppl = pfi->ppl; WINDOWPLACEMENT wp; ASSERTTRUE(ppl->iSig == PROP_SIG); if (!PifMgr_GetProperties(ppl, MAKELP(0,GROUP_FNT), &pfi->fntProposed, sizeof(pfi->fntProposed), GETPROPS_NONE) || !PifMgr_GetProperties(ppl, MAKELP(0,GROUP_WIN), &pfi->winOriginal, sizeof(pfi->winOriginal), GETPROPS_NONE)) { Warning(hDlg, IDS_QUERY_ERROR, MB_ICONEXCLAMATION | MB_OK); return; } /* * Set up instance variables for the window preview window. */ /* Show preview maximized if window is maximized or restores to max'd. * Also if it is open restored and has no scrollbars. * (Determined by comparing the client window size against the cell * size and font size.) */ pfi->fMax = FALSE; /* * Preload winOriginal with up-to-the-minute goodies, if we have * them. */ #define HasScrollbars(z) \ (pfi->winOriginal.c##z##Cells * pfi->fntProposed.c##z##FontActual > \ pfi->winOriginal.c##z##Client) if (ppl->hwndTty) { wp.length = sizeof(WINDOWPLACEMENT); VERIFYTRUE(GetWindowPlacement(ppl->hwndTty, &wp)); // Convert/Copy to 16-bit structure pfi->winOriginal.wLength = (WORD)wp.length; pfi->winOriginal.wShowFlags = (WORD)wp.flags; pfi->winOriginal.wShowCmd = (WORD)wp.showCmd; pfi->winOriginal.xMinimize = (WORD)wp.ptMinPosition.x; pfi->winOriginal.yMinimize = (WORD)wp.ptMinPosition.y; pfi->winOriginal.xMaximize = (WORD)wp.ptMaxPosition.x; pfi->winOriginal.yMaximize = (WORD)wp.ptMaxPosition.y; pfi->winOriginal.rcNormal.left = (WORD)wp.rcNormalPosition.left; pfi->winOriginal.rcNormal.top = (WORD)wp.rcNormalPosition.top; pfi->winOriginal.rcNormal.right = (WORD)wp.rcNormalPosition.right; pfi->winOriginal.rcNormal.bottom = (WORD)wp.rcNormalPosition.bottom; if (!IsIconic(ppl->hwndTty) && !HasScrollbars(x) && !HasScrollbars(y)) { pfi->fMax = TRUE; } } if ((pfi->winOriginal.wShowCmd == SW_SHOWMAXIMIZED) || (pfi->winOriginal.wShowFlags & WPF_RESTORETOMAXIMIZED)) { pfi->fMax = TRUE; } if (pfi->winOriginal.wShowCmd == SW_SHOWMAXIMIZED) { pfi->ptCorner.x = (LONG)pfi->winOriginal.xMaximize; pfi->ptCorner.y = (LONG)pfi->winOriginal.yMaximize; } else { if (pfi->winOriginal.rcNormal.left==0) { pfi->ptCorner.x = -1; } else { pfi->ptCorner.x = (LONG)pfi->winOriginal.rcNormal.left; } pfi->ptCorner.y = (LONG)pfi->winOriginal.rcNormal.top; } /* * First, check which fonts the user wants to see. * */ CheckDlgButton(hDlg, IDFROMFNTFLAGS(pfi->fntProposed.flFnt), TRUE); hwndList = GetDlgItem(hDlg, IDC_FONTSIZE); // SendMessage(hwndList, WM_SETFONT, (WPARAM)GetStockObject(SYSTEM_FIXED_FONT), FALSE); if (CreateFontList(hwndList, TRUE, &pfi->fntProposed) == LB_ERR) { MemoryWarning(hDlg); EndDialog(hDlg, PtrToLong(BPFDI_CANCEL)); /* Get out of the dialog */ return; } /* Initialize the preview windows */ PreviewInit(hDlg, pfi); PreviewUpdate(GetDlgItem(hDlg, IDC_FONTSIZE), pfi); } void ApplyFntDlg(HWND hDlg, register PFNTINFO pfi) { PPROPLINK ppl = pfi->ppl; ASSERTTRUE(ppl->iSig == PROP_SIG); if (!PifMgr_SetProperties(ppl, MAKELP(0,GROUP_FNT), &pfi->fntProposed, sizeof(pfi->fntProposed), SETPROPS_NONE)) Warning(hDlg, IDS_UPDATE_ERROR, MB_ICONEXCLAMATION | MB_OK); else if (ppl->hwndNotify) { ppl->flProp |= PROP_NOTIFY; PostMessage(ppl->hwndNotify, ppl->uMsgNotify, sizeof(pfi->fntProposed), (LPARAM)MAKELP(0,GROUP_FNT)); } } /* * Retrieves the name of the font to use for true-type DOS box * in a window given a registry tree root. * * Entry: * * hkRoot -> registry tree root to search * pszFaceSbcs -> LF_FACESIZE buffer for SBCS font * pszFaceDbcs -> LF_FACESIZE buffer for DBCS font (may be null) * * Exit: * * Buffers filled with new font names, or left unchanged if nothing * found in registry. * */ #define REGSTR_MSDOSEMU_FONT "Font" #define REGSTR_MSDOSEMU_FONTDBCS "FontDBCS" void GetDosBoxTtFontsHkA(HKEY hkRoot, LPSTR pszFaceSbcs, LPSTR pszFaceDbcs) { static CHAR const szMsdosemu[] = REGSTR_PATH_MSDOSEMU; HKEY hk; DWORD cb; if (RegOpenKeyExA(hkRoot, szMsdosemu, 0, KEY_READ, &hk) == ERROR_SUCCESS) { static CHAR const szFont[] = REGSTR_MSDOSEMU_FONT; cb = LF_FACESIZE; RegQueryValueExA(hk, szFont, 0, 0, (LPBYTE)pszFaceSbcs, &cb); if (pszFaceDbcs) { static CHAR const szDbcsFont[] = REGSTR_MSDOSEMU_FONTDBCS; cb = LF_FACESIZE; RegQueryValueExA(hk, szDbcsFont, 0, 0, (LPBYTE)pszFaceDbcs, &cb); } RegCloseKey(hk); } } /* * Retrieves the name of the font to use for true-type DOS box * in a window. * * This routine consults the appropriate registry keys. * * The DOS box font comes first from HKLM, to establish a * machine-wide default, but can in turn be overridden by * HKCU for each user to override. * * Entry: * * pszFaceSbcs -> LF_FACESIZE buffer for SBCS font * pszFaceDbcs -> LF_FACESIZE buffer for DBCS font (may be null) * * Exit: * * Buffers filled with new font names, or left unchange if nothing * found in registry. * */ void CoolGetDosBoxTtFontsA(LPSTR pszFaceSbcs, LPSTR pszFaceDbcs) { GetDosBoxTtFontsHkA(HKEY_LOCAL_MACHINE, pszFaceSbcs, pszFaceDbcs); GetDosBoxTtFontsHkA(HKEY_CURRENT_USER, pszFaceSbcs, pszFaceDbcs); } /** BroadcastFontChange * * HACK! for MS PowerPoint 4.0. These wallys, for some reason, will go * off and eat up reams of CPU time if they receive a WM_FONTCHANGE * message that was *posted*. But if the message is *sent*, they do * the right thing. The puzzling thing is that they never call * InSendMessage(), so how do they know? What's more, why do they care? * This was true in 3.1 also. What's their problem? * * The problem is that sending a broadcast risks deadlock city; see the * various hacks in winoldap for places where DDE broadcasting is bypassed. * In addition, since BroadcastFontChange is also called during the WEP, * multi-threaded apps will deadlock if we SendMessage back to a window * on a different thread in the app, because Kernel takes a process * critical section during DLL unload. * * So if PowerPig is running, we just don't tell anybody that we dorked * with the fonts. * * Returns: * * None. * */ void BroadcastFontChange(void) { if (!GetModuleHandle(szPP4)) { PostMessage(HWND_BROADCAST, WM_FONTCHANGE, 0, 0L); } } /** LoadGlobalFontData * * Get the name of the DOS box raster font and load it. * * Get the name of the TT font. (CheckDisplayParameters needs this.) * * Check the display parameters. * * Initialize the fdi cache. The cache remains in GlobalLock'd * memory throughout its lifetime. This is not a problem because * we are guaranteed to be in protected mode. * * We also load things necessary for the font combo/list boxes. * * And compute the height of the owner-draw list box item. * * Returns: * * TRUE on success. In which case the FDI cache and hbmFont * are ready to use. * * FALSE on failure. In which case there is insufficient memory * to complete the operation. */ typedef void (WINAPI *LPFNGDBTF)(LPTSTR, LPTSTR); /* GetDosBoxTtFonts */ BOOL LoadGlobalFontData(void) { HDC hDC; TEXTMETRIC tm; TCHAR szBuffer[MAXPATHNAME]; cxScreen = GetSystemMetrics(SM_CXSCREEN); cyScreen = GetSystemMetrics(SM_CYSCREEN); /* * Get the system char size and save it away for later use. */ hDC = GetDC(NULL); SelectObject(hDC, GetStockObject(SYSTEM_FONT)); GetTextMetrics(hDC, &tm); ReleaseDC(NULL, hDC); dyChar = tm.tmHeight + tm.tmExternalLeading; dyItem = max(tm.tmHeight, DY_TTBITMAP); /* * Chicago's AddFontResource looks in the FONTS directory first, which * is great because it saves us the trouble of doing goofy disk access * optimizations. */ GetPrivateProfileString(sz386EnhSection, szWOAFontKey, c_szNULL, szBuffer, ARRAYSIZE(szBuffer), szSystemINI); if (szBuffer[0] && AddFontResource(szBuffer)) { BroadcastFontChange(); } /* * Add DBCS native font if it is present. */ GetPrivateProfileString(sz386EnhSection, szWOADBCSFontKey, c_szNULL, szBuffer, ARRAYSIZE(szBuffer), szSystemINI); if (szBuffer[0] && AddFontResource(szBuffer)) { BroadcastFontChange(); } /* * Load default TT font name(s) and TT cache section names from resource */ LoadStringA(g_hinst, IDS_TTFACENAME_SBCS, szTTFaceName[0], ARRAYSIZE(szTTFaceName[0])); LoadString(g_hinst,IDS_TTCACHESEC_SBCS, szTTCacheSection[0], ARRAYSIZE(szTTCacheSection[0])); if (IsBilingualCP(g_uCodePage)) { LoadStringA(g_hinst, IDS_TTFACENAME_DBCS, szTTFaceName[1], ARRAYSIZE(szTTFaceName[1])); LoadString(g_hinst, IDS_TTCACHESEC_DBCS, szTTCacheSection[1], ARRAYSIZE(szTTCacheSection[1])); } CoolGetDosBoxTtFontsA(szTTFaceName[0], szTTFaceName[1]); CheckDisplayParameters(); // alloc needed # of cache // lpCache = (LPVOID)LocalAlloc(LPTR, FDI_TABLE_START * sizeof(FONTDIMENINFO) * (IsBilingualCP(g_uCodePage)? 2:1)); if (!lpCache) return FALSE; hcursorWait = LoadCursor(NULL, IDC_WAIT); UpdateTTBitmap(); if (!hbmFont) goto E0; // set initial value of # of cache entries which depends on whether we have // two codepage to handle // cfdiCacheActual[0] = FDI_TABLE_START; if (IsBilingualCP(g_uCodePage)) { cfdiCacheActual[1] = FDI_TABLE_START; bpfdiStart[1] += FDI_TABLE_START; } FontSelInit(); return TRUE; E0: EVAL(LocalFree(lpCache) == NULL); return FALSE; } void FreeGlobalFontData() { TCHAR szBuffer[MAXPATHNAME] = {0}; if (hbmFont) DeleteObject(hbmFont); EVAL(LocalFree(lpCache) == NULL); GetPrivateProfileString(sz386EnhSection, szWOAFontKey, c_szNULL, szBuffer, ARRAYSIZE(szBuffer), szSystemINI); if (*szBuffer) { if (RemoveFontResource(szBuffer)) { BroadcastFontChange(); } } GetPrivateProfileString(sz386EnhSection, szWOADBCSFontKey, c_szNULL, szBuffer, ARRAYSIZE(szBuffer), szSystemINI); if (*szBuffer) { if (RemoveFontResource(szBuffer)) { BroadcastFontChange(); } } } BOOL LoadGlobalFontEditData() { WNDCLASS wc; // Set up the window preview class for piffnt.c wc.style = 0L; wc.lpfnWndProc = WndPreviewWndProc; wc.cbClsExtra = 0; wc.cbWndExtra = sizeof(PFNTINFO); wc.hInstance = g_hinst; wc.hIcon = NULL; wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1); wc.lpszMenuName = NULL; wc.lpszClassName = szWndPreviewClass; // Don't go through RegisterClassD because we manually unregister // this class ourselves. if (!RealRegisterClass(&wc)) return FALSE; // Set up the font preview class for piffnt.c wc.style = 0L; wc.lpfnWndProc = FontPreviewWndProc; wc.cbClsExtra = 0; wc.cbWndExtra = sizeof(PFNTINFO); wc.hInstance = g_hinst; wc.hIcon = NULL; wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = GetStockObject(BLACK_BRUSH); wc.lpszMenuName = NULL; wc.lpszClassName = szFontPreviewClass; // Don't go through RegisterClassD because we manually unregister // this class ourselves. if (!RealRegisterClass(&wc)) return FALSE; return TRUE; } void FreeGlobalFontEditData() { UnregisterClass(szWndPreviewClass, g_hinst); UnregisterClass(szFontPreviewClass, g_hinst); } /* * Make sure that the display parameters have not changed, including * the name of the TT font(s). * * If they have, we BLAST OUR CACHE since it is no longer any good. * * Entry: * szTTFaceName contains the name of the TrueType font to use. * * Returns: * None. */ void CheckDisplayParameters(void) { HDC hIC; HKEY hk; DISPLAYPARAMETERS dpTrue, dpStored; hIC = CreateIC(szDisplay, 0, 0, 0); if (!hIC) { /* * If things are really screwy, stay conservative and assume * that all is well. */ return; } dpTrue.dpHorzSize = GetDeviceCaps(hIC, HORZSIZE); dpTrue.dpVertSize = GetDeviceCaps(hIC, VERTSIZE); dpTrue.dpHorzRes = GetDeviceCaps(hIC, HORZRES); dpTrue.dpVertRes = GetDeviceCaps(hIC, VERTRES); dpTrue.dpLogPixelsX = GetDeviceCaps(hIC, LOGPIXELSX); dpTrue.dpLogPixelsY = GetDeviceCaps(hIC, LOGPIXELSY); dpTrue.dpAspectX = GetDeviceCaps(hIC, ASPECTX); dpTrue.dpAspectY = GetDeviceCaps(hIC, ASPECTY); dpTrue.dpBitsPerPixel = GetDeviceCaps(hIC, BITSPIXEL); DeleteDC(hIC); /* * Since szTTFaceName is pre-initialized to "Courier New" padded * with nulls, we can rely on the garbage after the end of the * string always to be the same, so that a pure memory comparison * will work. */ MultiByteToWideChar(CP_ACP, 0, szTTFaceName[0], -1, dpTrue.szTTFace[0], ARRAYSIZE(dpTrue.szTTFace[0])); if (IsBilingualCP(g_uCodePage)) MultiByteToWideChar(CP_ACP, 0, szTTFaceName[1], -1, dpTrue.szTTFace[1], ARRAYSIZE(dpTrue.szTTFace[1])); /* * We must store the dimension information in the registry because * the install program for Omar Sharif Bridge will ERASE! your * SYSTEM.INI if it contains a line greater than 78 characters. * (I am not making this up. How could I?) */ if (RegCreateKey(HKEY_LOCAL_MACHINE, TEXT(REGSTR_PATH_MSDOSEMU), &hk) == 0) { DWORD cb = sizeof(DISPLAYPARAMETERS); if (SHQueryValueEx(hk, REGSTR_MSDOSEMU_DISPLAYPARAMS, 0, 0, (LPVOID)&dpStored, &cb) != 0 || cb != sizeof(DISPLAYPARAMETERS) || IsBufferDifferent(&dpTrue, &dpStored, sizeof(DISPLAYPARAMETERS))) { /* * Not much we can do if the write fails, so don't check. */ VERIFYTRUE(RegSetValueEx(hk, REGSTR_MSDOSEMU_DISPLAYPARAMS, 0, REG_BINARY, (LPVOID)&dpTrue, cb) == 0); /* Blast the font dimension cache */ WritePrivateProfileString(szTTCacheSection[1], NULL, NULL, szSystemINI); if (IsBilingualCP(g_uCodePage)) WritePrivateProfileString(szTTCacheSection[0], NULL, NULL, szSystemINI); } VERIFYTRUE(RegCloseKey(hk) == 0); } else { /* * Couldn't access registry. Oh well. */ } } /* * When the dialog box is created, we create the Window * Preview child window, as well as the Font Preview window. * * The creation is deferred until the actual dialog box creation * because the size and shape of the Window Preview window depends * on the current video driver. */ void PreviewInit(HWND hDlg, PFNTINFO pfi) { HWND hwnd; RECT rectLabel, rcPreview; /* * Compute the size of our preview window. * * The top is aligned with the top of IDC_WNDPREVIEWLBL, * minus a top margin of 3/2 dyChar. * The left edge is aligned with the left edge of IDC_WNDPREVIEWLBL. * The maximum width is the width of IDC_WNDPREVIEWLBL. * The bottom edge can go as far down as the bottom of the dialog, * minus a bottom margin of 3/2 dyChar. * And the shape of the preview window is determined by the screen * dimensions. * * We make the preview window as large as possible, given these * constraints. * */ GetWindowRect(GetDlgItem(hDlg, IDC_WNDPREVIEWLBL), &rectLabel); ScreenToClient(hDlg, (LPPOINT)&rectLabel); ScreenToClient(hDlg, (LPPOINT)&rectLabel.right); /* * This GetWindowRect/ScreenToClient sets rcPreview.top. */ GetWindowRect(GetDlgItem(hDlg, IDC_WNDPREVIEWLBL), &rcPreview); ScreenToClient(hDlg, (LPPOINT)&rcPreview); /* * Compute height based on width. */ rcPreview.top += 3 * dyChar / 2; rcPreview.left = rectLabel.left; rcPreview.right = rectLabel.right - rectLabel.left; rcPreview.bottom = AspectScale(cyScreen, cxScreen, rcPreview.right); /* * Phew. Now we can create the preview window. */ hwnd = CreateWindowEx( WS_EX_CLIENTEDGE, szWndPreviewClass, NULL, WS_CHILD | WS_VISIBLE, rcPreview.left, rcPreview.top, rcPreview.right, rcPreview.bottom, hDlg, (HMENU)IDC_WNDPREVIEW, g_hinst, NULL); if (hwnd) SetWindowLongPtr(hwnd, 0, (LONG_PTR)pfi); /* * Compute the size of the font preview. This is easier. */ GetWindowRect(GetDlgItem(hDlg, IDC_FONTPREVIEWLBL), &rectLabel); ScreenToClient(hDlg, (LPPOINT)&rectLabel.left); ScreenToClient(hDlg, (LPPOINT)&rectLabel.right); hwnd = CreateWindowEx( WS_EX_CLIENTEDGE, szFontPreviewClass, NULL, WS_CHILD | WS_VISIBLE, rectLabel.left, rectLabel.top + 3 * dyChar / 2, rectLabel.right - rectLabel.left, rcPreview.bottom, hDlg, (HMENU)IDC_FONTPREVIEW, g_hinst, NULL); if (hwnd) SetWindowLongPtr(hwnd, 0, (LONG_PTR)pfi); } /* PreviewUpdate * * Does the preview of the selected font. */ void PreviewUpdate(HWND hwndList, PFNTINFO pfi) { HWND hDlg; BPFDI bpfdi; /* Delete the old font if necessary */ if (pfi->hFontPreview) { DeleteObject(pfi->hFontPreview); pfi->hFontPreview = NULL; } /* When we select a font, we do the font preview by setting it * into the appropriate list box */ bpfdi = (BPFDI)GetFont(hwndList, TRUE, pfi); if (IsSpecialBpfdi(bpfdi)) return; /* Update our internal font structure so that preview window * will actually change */ pfi->bpfdi = bpfdi; SetFont(&pfi->fntProposed, bpfdi); /* Make the new font */ pfi->hFontPreview = CreateFontFromBpfdi(bpfdi, pfi); /* Force the preview windows to repaint */ hDlg = GetParent(hwndList); InvalidateRect(GetDlgItem(hDlg, IDC_WNDPREVIEW), NULL, TRUE); InvalidateRect(GetDlgItem(hDlg, IDC_FONTPREVIEW), NULL, TRUE); } /* WndPreviewWndProc * * Handles the window preview window. */ LRESULT WndPreviewWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { case WM_PAINT: WndPreviewPaint(GetParent(hwnd), hwnd); break; case WM_HELP: // Handles title bar help button message WinHelp(hwnd, NULL, HELP_CONTEXTPOPUP, IDH_DOS_FONT_WINDOW_PREVIEW); break; case WM_RBUTTONUP: case WM_NCRBUTTONUP: // Equivalent of WM_CONTEXTMENU OnWmContextMenu((WPARAM)hwnd, &rgdwHelp[0]); break; default: return DefWindowProc(hwnd, uMsg, wParam, lParam); } return 0; } /* Swiped from Control Panel / Metrics. * * Draws the frame *and* modifies the rectangle to contain the * shrunk coordinates. */ void _DrawFrame(HDC hdc, int clr, LPRECT lprc, int cx, int cy) { HBRUSH hbr; RECT rcT; CopyRect(&rcT, lprc); hbr = SelectObject(hdc, GetSysColorBrush(clr)); /* Left */ PatBlt(hdc, rcT.left, rcT.top, cx, rcT.bottom-rcT.top, PATCOPY); rcT.left += cx; /* Top */ PatBlt(hdc, rcT.left, rcT.top, rcT.right-rcT.left, cy, PATCOPY); rcT.top += cy; /* Right */ rcT.right -= cx; PatBlt(hdc, rcT.right, rcT.top, cx, rcT.bottom-rcT.top, PATCOPY); /* Bottom */ rcT.bottom -= cy; PatBlt(hdc, rcT.left, rcT.bottom, rcT.right-rcT.left, cy, PATCOPY); SelectObject(hdc, hbr); CopyRect(lprc, &rcT); } /* WndPreviewPaint * * Paints the window preview window. This is called from its * paint message handler. * */ void WndPreviewPaint(HWND hDlg, HWND hwnd) { PPROPLINK ppl; PFNTINFO pfi; RECT rcPreview; RECT rcWin; RECT rcClient; RECT rcT; POINT ptButton; #define cxButton ptButton.x #define cyButton ptButton.y POINT ptCorner; POINT ptFrame; #define cxFrame ptFrame.x #define cyFrame ptFrame.y BPFDI bpfdi; int cxBorder, cyBorder; int dyToolbar; PAINTSTRUCT ps; BOOL bCenter; BeginPaint(hwnd, &ps); pfi = (PFNTINFO)GetWindowLongPtr(hwnd, 0); ppl = pfi->ppl; ASSERTTRUE(ppl->iSig == PROP_SIG); bpfdi = pfi->bpfdi; /* If we don't have a font, get out */ if (!pfi->hFontPreview) return; /* Get the width of the preview "screen" */ GetClientRect(hwnd, &rcPreview); /* Figure out how large we would be as a result of the change. * This isn't perfect, but it'll probably be close enough. * (Imperfection if we chose AUTO as the font.) */ /* Assume maximized */ rcClient.left = rcClient.top = 0; if (pfi->winOriginal.cxCells) { rcClient.right = pfi->winOriginal.cxCells * bpfdi->fdiWidthActual; } else { rcClient.right = 80 * bpfdi->fdiWidthActual; } if (pfi->winOriginal.cyCells) { rcClient.bottom = pfi->winOriginal.cyCells * bpfdi->fdiHeightActual; } else { PROPVID vid; // set default value rcClient.bottom = 25 * bpfdi->fdiHeightActual; // now see if there is a value in the pif file for size of window... if (PifMgr_GetProperties(ppl, MAKELP(0,GROUP_VID), &vid, sizeof(vid), GETPROPS_NONE)) { if (vid.cScreenLines > 0) rcClient.bottom = vid.cScreenLines * bpfdi->fdiHeightActual; } } if (!pfi->fMax && pfi->winOriginal.cxClient && pfi->winOriginal.cyClient) { /* Shrink down to window actual */ if (rcClient.right > (int)pfi->winOriginal.cxClient) rcClient.right = (int)pfi->winOriginal.cxClient; if (rcClient.bottom > (int)pfi->winOriginal.cyClient) rcClient.bottom = (int)pfi->winOriginal.cyClient; } /* Get some more metrics */ cxBorder = GetSystemMetrics(SM_CXBORDER); cyBorder = GetSystemMetrics(SM_CYBORDER); cxButton = GetSystemMetrics(SM_CXSIZE); cyButton = GetSystemMetrics(SM_CYSIZE); // cyButton *= 2; /* Double the height for "looks" */ cxFrame = GetSystemMetrics(SM_CXFRAME); cyFrame = GetSystemMetrics(SM_CYFRAME); /* FLAG DAY! Convert everything from desktop coordinates to * aspect ratio-scaled preview coordinates * * Do **not** convert cxBorder and cyBorder! * * ptCorner must not be modified in-place since its value is used at * the next go-round. * * After translation, cxFrame and cyFrame are adjusted so that the * cxBorder counts against them. This allows for users who set * really wide frames, but doesn't penalize the users who have * narrow frames. */ ptCorner = pfi->ptCorner; bCenter = (ptCorner.x == -1); AspectPoint(&rcPreview, &ptCorner); AspectPoint(&rcPreview, &ptFrame); AspectRect(&rcPreview, &rcClient); AspectPoint(&rcPreview, &ptButton); /* * The height of a toolbar is hard-coded at 30 pixels. */ if (pfi->winOriginal.flWin & WIN_TOOLBAR) { dyToolbar = (int)AspectScale(rcPreview.bottom, cyScreen, 30); } else { dyToolbar = 0; } /* Make sure the buttons are nonzero in dimension */ if (cxButton == 0) cxButton = 1; if (cyButton == 0) cyButton = 1; /* * Don't penalize people who have thin frames. */ if (cxFrame < cxBorder) cxFrame = cxBorder; if (cyFrame < cyBorder) cyFrame = cyBorder; /* * Convert from client rectangle back to window rectangle. * * We must do this *AFTER* the flag day, because we need to use the * post-flag day cxBorder and cyBorder. */ /* Put a (scaled-down) toolbar into place. We'll expand the client * region to accomodate it. (We'll subtract the toolbar off before * painting the client region.) */ rcClient.bottom += dyToolbar; /* Shove the client region down to make room for the caption. */ OffsetRect(&rcClient, 0, cyButton); rcWin = rcClient; rcWin.top = 0; InflateRect(&rcWin, cxFrame, cyFrame); /* * Now put it in the proper position on the (shrunk-down) desktop. * We cannot do this until rcWin's value is finalized. */ if (bCenter) { ptCorner.x = ((rcPreview.right - rcPreview.left) - (rcWin.right - rcWin.left) ) / 2; if (ptCorner.x < 0) ptCorner.x = 0; ptCorner.y = ((rcPreview.bottom - rcPreview.top) - (rcWin.bottom - rcWin.top) ) / 5; if (ptCorner.y < 0) ptCorner.y = 0; } OffsetRect(&rcWin, ptCorner.x, ptCorner.y); OffsetRect(&rcClient, ptCorner.x, ptCorner.y); /* It's party time! */ /* The outer border */ DrawEdge(ps.hdc, &rcWin, BDR_RAISEDINNER, BF_RECT | BF_ADJUST); /* The sizing frame */ _DrawFrame(ps.hdc, COLOR_ACTIVEBORDER, &rcWin, cxFrame - cxBorder, cyFrame - cyBorder); /* rcWin has now shrunk to its inner edge */ /* Move its bottom edge upwards to meet the top of the client region. * This turns rcWin into the caption area. */ rcWin.bottom = rcClient.top; FillRect(ps.hdc, &rcWin, (HBRUSH)(COLOR_ACTIVECAPTION+1)); /* Next comes the toolbar */ rcT= rcClient; rcT.bottom = rcT.top + dyToolbar; FillRect(ps.hdc, &rcT, (HBRUSH)(COLOR_BTNFACE+1)); /* Next, draw the client region */ rcClient.top += dyToolbar; DrawEdge(ps.hdc, &rcClient, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST); FillRect(ps.hdc, &rcClient, (HBRUSH)GetStockObject(BLACK_BRUSH)); /* * Now draw the three caption buttons. */ /* * The system menu. */ rcT = rcWin; rcT.right = rcT.left + cxButton; //DrawFrameControl(ps.hdc, &rcT, DFC_SYSMENU, DFCS_SYSMENUMAIN); DrawFrameControl(ps.hdc, &rcT, DFC_CAPTION, DFCS_CAPTIONCLOSE); /* * The maximize menu. */ rcWin.left = rcWin.right - cxButton; //DrawFrameControl(ps.hdc, &rcWin, DFC_SIZE, DFCS_SIZEMAX); DrawFrameControl(ps.hdc, &rcWin, DFC_CAPTION, DFCS_CAPTIONMAX); /* * The minimize menu. */ rcWin.left -= cxButton; rcWin.right -= cxButton; //DrawFrameControl(ps.hdc, &rcWin, DFC_SIZE, DFCS_SIZEMIN); DrawFrameControl(ps.hdc, &rcWin, DFC_CAPTION, DFCS_CAPTIONMIN); EndPaint(hwnd, &ps); } #undef cxButton #undef cyButton #undef cxFrame #undef cyFrame LRESULT FontPreviewWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { RECT rect; PFNTINFO pfi; PAINTSTRUCT ps; switch (uMsg) { case WM_PAINT: BeginPaint(hwnd, &ps); pfi = (PFNTINFO)GetWindowLongPtr(hwnd, 0); /* Draw the font sample */ SelectObject(ps.hdc, pfi->hFontPreview); SetTextColor(ps.hdc, RGB(192, 192, 192)); SetBkColor(ps.hdc, RGB(0, 0, 0)); GetClientRect(hwnd, &rect); InflateRect(&rect, -2, -2); { TCHAR szPreviewText[300]; LoadString(g_hinst, IsBilingualCP(pfi->fntProposed.wCurrentCP) ? IDS_PREVIEWTEXT_BILNG : IDS_PREVIEWTEXT, szPreviewText, ARRAYSIZE(szPreviewText)); // load a sample for their native codepage DrawText(ps.hdc, szPreviewText, -1, &rect, 0); } EndPaint(hwnd, &ps); break; case WM_HELP: // Handles title bar help button message WinHelp(hwnd, NULL, HELP_CONTEXTPOPUP, IDH_DOS_FONT_FONT_PREVIEW); break; case WM_RBUTTONUP: case WM_NCRBUTTONUP: // Equivalent of WM_CONTEXTMENU OnWmContextMenu((WPARAM)hwnd, &rgdwHelp[0]); break; default: return DefWindowProc(hwnd, uMsg, wParam, lParam); } return 0; } /* * Loads the dialog control hwndList with all available font * dimensions for raster fonts, and a selected collection of * dimensions for TrueType fonts. * * The reference data for each control is an index into lpfniCache. * * The hourglass cursor is displayed during the font list build. * * Entry: * hwndList == handle to listbox or combo box to fill * fListBox == TRUE if hwndList is a listbox, FALSE if a combo box * lpFnt -> PROPFNT structure * * If HIWORD(lpFnt) is NULL, then LOWORD(lpFnt) is used as an hProps * to get obtain property info for that handle. * * Returns: * >= 0 on success, indicating the current selection. * In which case the FDI cache is valid and hwndList has been filled * with font information, and the currently-selected font has been * made the current selection. * * LB_ERR/CB_ERR on failure. The list box hwndList is left in an * indeterminate state. */ int WINAPI CreateFontList(HWND hwndList, BOOL fListBox, LPPROPFNT lpFnt) { DWORD dwIndex; HCURSOR hcursor; PROPFNT fntTemp; int iReturn = LB_ERR; TCHAR szBuf[MAXDIMENSTRING]; if (IS_INTRESOURCE(lpFnt)) { if (!PifMgr_GetProperties(lpFnt, MAKELP(0,GROUP_FNT), &fntTemp, sizeof(fntTemp), GETPROPS_NONE)) goto Exit2; lpFnt = &fntTemp; } /* * Put up an hourglass while the font list build is taking place, * since it might take a long time if we have to re-rasterize * TrueType fonts. * * NOTE! That we do not do a ShowCursor. Why? * * If the user is on a mouseless system, then he can't access his * toolbar, and hence the only time this code can get called is * during the creation of the font selection dialog box. In which * case, DialogBox has already done a ShowCursor for us. * */ hcursor = SetCursor(hcursorWait); /* * Initialize the list box. */ if (hwndList) { SendMessage(hwndList, WM_SETREDRAW, FALSE, 0L); SendMessage(hwndList, fListBox ? LB_RESETCONTENT : CB_RESETCONTENT, 0, 0L); } /* * Add the fonts. */ if ((lpFnt->flFnt & FNT_RASTERFONTS) && !AddRasterFontsToFontListA(hwndList, fListBox, lpFnt->achRasterFaceName, lpFnt->wCurrentCP)) goto Exit; if ((lpFnt->flFnt & FNT_TTFONTS) && !AddTrueTypeFontsToFontListA(hwndList, fListBox, lpFnt->achTTFaceName, lpFnt->wCurrentCP)) goto Exit; /* * And the magical "Auto" font size. */ /* * Beyond this point, success is assured, so at the very least, * DON'T return LB_ERR; we may optionally set the return code to * the current selection, below, too... */ iReturn = 0; if (hwndList) { /* * No error checking here because if anything fails, then the * end result will be merely that the "Auto" option either * (1) exists but is invisible, or (2) doesn't appear at all. */ LoadString(g_hinst, IDS_AUTO, szBuf, ARRAYSIZE(szBuf)); dwIndex = lcbInsertString(hwndList, fListBox, szBuf, 0); lcbSetItemDataPair(hwndList, fListBox, dwIndex, BPFDI_AUTO, 0); /* * Make yet another pass through the list to find the current * font and select it. Thanks to an intentional flakiness * in USER, we can't do this check at the point that the * font is added, because the selection does not move with the * item when a new item is inserted above the selection. * * Bleah. */ if (!MatchCurrentFont(hwndList, fListBox, lpFnt)) { /* * If no font matched the current font, and we are a list box, * then make the first font the current selection. * * We don't want to make any default selection if we are a * combo box, because that would make the user think that the * current font was something it wasn't. */ if (fListBox) { /* * SORTING-SENSITIVE! This assumes that "Auto" is at the top * of the list. */ lcbSetCurSel(hwndList, TRUE, 0); lpFnt->flFnt |= FNT_AUTOSIZE; } } SendMessage(hwndList, WM_SETREDRAW, TRUE, 0L); iReturn = lcbGetCurSel(hwndList, fListBox); } Exit: /* * Reset the mouse cursor. */ SetCursor(hcursor); Exit2: return iReturn; } /** UpdateTTBitmap * * Recompute the colors for the TrueType bitmap hbmFont. * * Since we may receive this several times for a single WM_SYSCOLORCHANGE, * we update our colors under the following conditions: * * 1. More than one second has elapsed since the previous call, or * 2. A crude checksum fails. * * Entry: * None. * * Returns: * hbmFont recomputed. */ VOID WINAPI UpdateTTBitmap(void) { COLORREF clr; /* * Note that the checksum should not be a symmetric function, * because a common color alteration is to exchange or permute * the colors. */ clr = + GetSysColor(COLOR_BTNTEXT) - GetSysColor(COLOR_BTNSHADOW) + (GetSysColor(COLOR_BTNFACE) ^ 1) - (GetSysColor(COLOR_BTNHIGHLIGHT) ^ 2) ^ GetSysColor(COLOR_WINDOW); if (!hbmFont || clr != clrChecksum || GetTickCount() - dwTimeCheck < 1000) { clrChecksum = clr; dwTimeCheck = GetTickCount(); if (hbmFont) DeleteObject(hbmFont); hbmFont = CreateMappedBitmap(g_hinst, IDB_TTBITMAP, 0, NULL, 0); } } /** DrawItemFontList * * Answer the WM_DRAWITEM message sent from the font list box or * font combo box. * * This code was originally lifted from FONT.C in sdk\commdlg. * * See fontutil.h for an explanation of the \1 hack. * * Entry: * fListBox = TRUE if the item is a list box, FALSE if a combo box * lpdis -> DRAWITEMSTRUCT describing object to be drawn * * Returns: * None. * * The object is drawn. */ #define cTabsList 3 typedef struct DIFLINFO { LPTSTR di_lpsz; PINT di_pTabs; } DIFLINFO, *LPDIFLINFO; #define lpdi ((LPDIFLINFO)lp) BOOL CALLBACK diflGrayStringProc(HDC hdc, LPARAM lp, int cch) { return (BOOL)TabbedTextOut(hdc, 0, 0, lpdi->di_lpsz, lstrlen(lpdi->di_lpsz), cTabsList, lpdi->di_pTabs, 0); } #undef lpdi VOID WINAPI DrawItemFontList(BOOL fListBox, const LPDRAWITEMSTRUCT lpdis) { HDC hDC, hdcMem; DWORD rgbBack, rgbText; int iColorBack; COLORREF clrText; COLORREF clrBack; TCHAR szDimen[MAXDIMENSTRING]; HBITMAP hOld; int dy; DIFLINFO di; static int rgTabsList[cTabsList] = {0, 0, 0}; static int rgTabsCombo[cTabsList] = {0, 0, 0}; #define lpsz di.di_lpsz #define pTabs di.di_pTabs if ((int)lpdis->itemID < 0) return; hDC = lpdis->hDC; if (lpdis->itemAction & ODA_FOCUS) { if (lpdis->itemState & ODS_SELECTED) { DrawFocusRect(hDC, &lpdis->rcItem); } } else { if (lpdis->itemState & ODS_SELECTED) { clrBack = GetSysColor(iColorBack = COLOR_HIGHLIGHT); clrText = GetSysColor(COLOR_HIGHLIGHTTEXT); } else { clrBack = GetSysColor(iColorBack = COLOR_WINDOW); clrText = GetSysColor(IsWindowEnabled(lpdis->hwndItem) ? COLOR_WINDOWTEXT : COLOR_GRAYTEXT); } rgbText = SetTextColor(hDC, clrText); rgbBack = SetBkColor(hDC, clrBack); // draw selection background FillRect(hDC, &lpdis->rcItem, (HBRUSH)UIntToPtr((iColorBack + 1))); // get the string SendMessage(lpdis->hwndItem, fListBox ? LB_GETTEXT : CB_GETLBTEXT, lpdis->itemID, (LPARAM)(LPTSTR)szDimen); lpsz = szDimen; if (szDimen[0] == TEXT('\1')) // hack for "Auto" string lpsz++; if (fListBox) pTabs = rgTabsList; else pTabs = rgTabsCombo; if (pTabs[0] == 0) { /* Never seen this font before */ /* Assumes GetTextExtent(hDC, ANSI_TIMES, 1) < 2 * dxChar */ SIZE sSize; GetTextExtentPoint32(hDC, szZero, 1, &sSize); // size of '0' /* A negative # for tab stop right aligns the tabs... */ pTabs[0] = -sSize.cx * 3; pTabs[1] = -sSize.cx * 5; pTabs[2] = -sSize.cx * 8; } // draw the text // // Note that the SDK dox for GrayString says that you can detect // whether GrayString is needed by saying // // if (GetSysColor(COLOR_GRAYTEXT) == 0) { // GrayString(...); // } else { // TextOut(...); // } // // This is incorrect. The correct test is the one below, which // also catches bad color combinations on color devices. // if (clrText == clrBack) { SetTextColor(hDC, GetSysColor(COLOR_WINDOWTEXT)); GrayString(hDC, GetStockObject(GRAY_BRUSH), diflGrayStringProc , (LPARAM)(LPVOID)&di, 0, lpdis->rcItem.left + DX_TTBITMAP, lpdis->rcItem.top, lpdis->rcItem.right - lpdis->rcItem.left - DX_TTBITMAP, lpdis->rcItem.bottom - lpdis->rcItem.top); } else { TabbedTextOut(hDC, lpdis->rcItem.left + DX_TTBITMAP, lpdis->rcItem.top, lpsz, lstrlen(lpsz), cTabsList, pTabs, DX_TTBITMAP); } // and the bitmap if needed if (!IsSpecialBpfdi((BPFDI)lpdis->itemData)) { if (((BPFDI)(lpdis->itemData))->bTT) { hdcMem = CreateCompatibleDC(hDC); if (hdcMem) { hOld = SelectObject(hdcMem, hbmFont); dy = ((lpdis->rcItem.bottom - lpdis->rcItem.top) - DY_TTBITMAP) / 2; BitBlt(hDC, lpdis->rcItem.left, lpdis->rcItem.top + dy, DX_TTBITMAP, DY_TTBITMAP, hdcMem, 0, lpdis->itemState & ODS_SELECTED ? 0 : DY_TTBITMAP, SRCCOPY); if (hOld) SelectObject(hdcMem, hOld); DeleteDC(hdcMem); } } } SetTextColor(hDC, rgbText); SetBkColor(hDC, rgbBack); if (lpdis->itemState & ODS_FOCUS) { DrawFocusRect(hDC, &lpdis->rcItem); } } } #undef lpsz #undef pTabs /** MeasureItemFontList * * Answer the WM_MEASUREITEM message sent from the font list box or * font combo box. shared between the toolbar combo box code and * the font preview property sheet * * Entry: * lpmi -> LPMEASUREITEMSTRUCT describing object to be measured * * Returns: * TRUE. * * lpmi->itemHeight filled with actual item height. */ LONG WINAPI MeasureItemFontList(LPMEASUREITEMSTRUCT lpmi) { lpmi->itemHeight = dyItem; return TRUE; } /** GetItemFontInfo * * Returns font information for the current selection in the given * listbox/combobox. * * Entry: * hwndList == handle to listbox or combo box to fill * if NULL, then AUTO is assumed * fListBox == TRUE if hwndList is a listbox, FALSE if a combo box * hProps == property handle * lpFnt -> PROPFNT structure (filled in upon return) * * Returns: * LB_ERR/CB_ERR on error, index of current selection otherwise */ int WINAPI GetItemFontInfo(HWND hwndList, BOOL fListBox, HANDLE hProps, LPPROPFNT lpFnt) { DWORD_PTR dw; int index; /* * Get font defaults; the nice thing about this call is that * it also takes care of calling ChooseBestFont if AUTOSIZE is set, * which means we can tell GetFont() to not bother. */ PifMgr_GetProperties(hProps, MAKELP(0,GROUP_FNT), lpFnt, sizeof(PROPFNT), GETPROPS_NONE); dw = GetFont(hwndList, fListBox, NULL); if (IsSpecialBpfdi((BPFDI)dw)) { return 0; } index = ((BPFDI)dw)->Index; if (index == 0) lpFnt->flFnt |= FNT_AUTOSIZE; else if (index > 0) lpFnt->flFnt &= ~FNT_AUTOSIZE; /* * Fill the caller's PROPFNT structure with all the font goodies (if any) * * Note that this does nothing if we ended up picking the AUTO font. */ SetFont(lpFnt, (BPFDI)dw); return index; } /** MatchCurrentFont * * Locates the current font in the indicated list box and * makes him the current selection. * * If we are in auto-mode, then "Auto" is selected. * * Entry: * hwndList == handle to listbox or combo box * fListBox == TRUE if hwndList is a listbox, FALSE if a combo box * lpFnt -> PROPFNT structure * * Returns: * TRUE if the current font was found and selected. */ BOOL WINAPI MatchCurrentFont(HWND hwndList, BOOL fListBox, LPPROPFNT lpFnt) { BPFDI bpfdi; DWORD dwCount, dwIndex; BOOL fCurFontIsTt = !!(lpFnt->flFnt & FNT_TT); if (lpFnt->flFnt & FNT_AUTOSIZE) { /* * SORTING-SENSITIVE! This assumes that "Auto" is at the top * of the list. */ lcbSetCurSel(hwndList, fListBox, 0); return TRUE; } dwCount = lcbGetCount(hwndList, fListBox); for (dwIndex = 0; dwIndex < dwCount; dwIndex++) { bpfdi = lcbGetBpfdi(hwndList, fListBox, dwIndex); if (!IsSpecialBpfdi(bpfdi)) { // bpfdi = (BPFDI)((DWORD)bpfdi + (DWORD)lpCache); if (bpfdi->fdiWidthActual == lpFnt->cxFontActual && bpfdi->fdiHeightActual == lpFnt->cyFontActual && fCurFontIsTt == (bpfdi->fdiHeightReq != 0)) { lcbSetCurSel(hwndList, fListBox, dwIndex); return TRUE; } } } return FALSE; } /** AddRasterFontsToFontList * * Enumerate the available dimensions for our OEM raster font * and add them to the list or combo box. * * Entry: * hwndList = List box or combo box to fill with info * fListBox = TRUE if hwndList is a listbox, FALSE if a combo box * lpszRasterFaceName * * Returns: * TRUE if fonts were enumerated to completion. * FALSE if enumeration failed. (Out of memory.) * */ BOOL AddRasterFontsToFontListA(HWND hwndList, BOOL fListBox, LPCSTR lpszRasterFaceName, INT CodePage) { HDC hDC; BOOL fSuccess; FNTENUMINFO FntEnum; hDC = GetDC(hwndList); if (!hDC) return FALSE; FntEnum.hwndList = hwndList; FntEnum.fListBox = fListBox; FntEnum.CodePage = CodePage; fSuccess = EnumFontFamiliesA(hDC, lpszRasterFaceName, (FONTENUMPROCA)RasterFontEnum, (LPARAM)&FntEnum); ReleaseDC(hwndList, hDC); return TRUE; } /** RasterFontEnum * * FONTENUMPROC for enumerating all available dimensions of the OEM * raster font. * * This routine is used to load the logical and physical font * dimensions cache with information about raster fonts. * * Entry: * lpelf \ * lpntm > from EnumFonts (see SDK) * nFontType / * hwndList = List box or combo box to fill with info * fListBox = TRUE if hwndList is a listbox, FALSE if a combo box * * Returns: * TRUE to continue enumeration. * FALSE to stop enumeration. (Out of memory.) */ int CALLBACK RasterFontEnum(ENUMLOGFONTA *lpelf, NEWTEXTMETRICA *lpntm, int nFontType, LPARAM lParam) { #define fListBox (((LPFNTENUMINFO)lParam)->fListBox) #define hwndList (((LPFNTENUMINFO)lParam)->hwndList) #define CodePage (((LPFNTENUMINFO)lParam)->CodePage) #define lpLogFont (&(lpelf->elfLogFont)) /* * We only care about OEM fixed-pitch fonts. */ if (lpLogFont->lfCharSet != OEMCharsetFromCP(CodePage) || (lpLogFont->lfPitchAndFamily & (TMPF_TRUETYPE | TMPF_FIXED_PITCH)) != TMPF_FIXED_PITCH) return TRUE; return AddToFontListCache(hwndList, fListBox, 0, 0, lpLogFont->lfHeight, lpLogFont->lfWidth, CodePage) != BPFDI_CANCEL; #undef lpLogFont #undef fListBox #undef hwndList #undef CodePage } /** AddToFontListCache * * Adds an entry to the font dimension information cache, * growing the cache if necessary. * * It also adds the entry to the indicated list box, provided * the entry is not a duplicate. * * Returns: * BPFDI of the recently-added font, or BPFDI_CANCEL if out of memory. * * Overview: * (1) Grow the cache if necessary. * (2) Add the information to the list/combo box. * (3) Add the information to the cache. */ BPFDI AddToFontListCache(HWND hwndList, BOOL fListBox, UINT uHeightReq, UINT uWidthReq, UINT uHeightActual, UINT uWidthActual, UINT uCodePage) { LPVOID hCache; LONG_PTR lCacheSave; DWORD dwIndex, ifdi; BPFDI bpfdi; TCHAR szBuf[MAXDIMENSTRING]; int idx; ASSERT(!((uHeightReq==0) && (uWidthReq==0) && (uHeightActual==0) && (uWidthActual==0))); /* Reject too-large fonts out of hand. */ if (uHeightActual > MAX_FONT_HEIGHT) { return BPFDI_IGNORE; } /* * FIRST, determine whether this font entry has already been cached */ // we maintain two set of cache entries in case we have two code page // to support // idx = IsBilingualCP(uCodePage) ? 1 : 0; for (ifdi = 0, bpfdi = (BPFDI)((DWORD_PTR)lpCache + bpfdiStart[idx]); ifdi < cfdiCache[idx]; ++ifdi, ++bpfdi) { if (bpfdi->fdiWidthReq == uWidthReq && bpfdi->fdiHeightReq == uHeightReq && bpfdi->fdiWidthActual == uWidthActual && bpfdi->fdiHeightActual == uHeightActual) goto UpdateListCombo; } /* * Grow the cache if necessary. */ if (cfdiCache[idx] >= cfdiCacheActual[idx]) { /* * save offset from beginning of cache */ bpfdi = (BPFDI)((DWORD_PTR)bpfdi - (DWORD_PTR)lpCache); /* * save current lpCache value so can adjust entries in listbox * when we're done... */ lCacheSave = (LONG_PTR)lpCache; hCache = LocalReAlloc(lpCache, (cfdiCacheActual[0] + cfdiCacheActual[1] + FDI_TABLE_INC) * sizeof(FONTDIMENINFO), LMEM_ZEROINIT|LMEM_MOVEABLE); if (!hCache) return BPFDI_CANCEL; lpCache = hCache; if (!idx && IsBilingualCP(g_uCodePage)) { /* * We need to shift 2nd cache before using expanded 1st chache */ BPFDI bpfdi2; for (ifdi = cfdiCache[1], bpfdi2 = (BPFDI)((DWORD_PTR)lpCache + bpfdiStart[1]) + ifdi - 1 + FDI_TABLE_INC ; ifdi ; ifdi--, bpfdi2--) { *bpfdi2 = *(bpfdi2 - FDI_TABLE_INC); } bpfdiStart[1] += FDI_TABLE_INC; } /* restore bpfdi from saved offset */ bpfdi = (BPFDI)((DWORD_PTR)lpCache + (DWORD_PTR)bpfdi); cfdiCacheActual[idx] += FDI_TABLE_INC; /* * Convert lCacheSave to an offset... */ lCacheSave = (LONG_PTR)lpCache - lCacheSave; if (lCacheSave) { /* * Now, adjust each entry in the listbox to account for the new * relocated cache position.. */ dwIndex = lcbGetCount(hwndList, fListBox); for(ifdi = 0; ifdi < dwIndex; ifdi++) { LONG_PTR lBpfdi; lBpfdi = (LONG_PTR)lcbGetItemDataPair(hwndList, fListBox, ifdi); if (!IsSpecialBpfdi((BPFDI)lBpfdi)) { lBpfdi += lCacheSave; lcbSetItemDataPair(hwndList, fListBox, ifdi, lBpfdi, ((BPFDI)lBpfdi)->bTT); } } } } /* * Now add the information to the cache. All the casting on bpfdiCache * is just to inhibit a bogus compiler complaint. */ bpfdi->fdiWidthReq = uWidthReq; bpfdi->fdiHeightReq = uHeightReq; bpfdi->fdiWidthActual = uWidthActual; bpfdi->fdiHeightActual = uHeightActual; cfdiCache[idx]++; UpdateListCombo: if (hwndList) { /* * Add the string to the list/combo box if it isn't there already. */ wsprintf(szBuf, TEXT("\t%2d\tx\t%2d"), uWidthActual, uHeightActual); dwIndex = lcbFindStringExact(hwndList, fListBox, szBuf); if (IsDlgError(dwIndex)) { /* * Not already on the list. Add it. */ dwIndex = lcbAddString(hwndList, fListBox, szBuf); if (IsDlgError(dwIndex)) { return BPFDI_CANCEL; } lcbSetItemDataPair(hwndList, fListBox, dwIndex, bpfdi, uHeightReq); } } return bpfdi; } /** AddTrueTypeFontsToFontListA * * To avoid rasterizing all the fonts unnecessarily, we load the * information from the szTTCacheSection font cache. * * Note that the cache information is not validated! We just * assume that if the value is in the cache, it is valid. * * Entry: * hwndList = List box or combo box to fill with info * fListBox = TRUE if hwndList is a listbox, FALSE if a combo box * lpszTTFaceName * * Returns: * TRUE if fonts were enumerated to completion. * FALSE if enumeration failed. (Out of memory.) * * Caveats: * The ParseIniWords call assumes that the values were written * by AddOneNewTrueTypeFontToFontList, who wrote them out so * that a single call to ParseIniWords will read the height and * width directly into a dwHeightWidth. * * Similarly, the second ParseIniWords reads the item directly into * a dwHeightWidth. */ BOOL AddTrueTypeFontsToFontListA(HWND hwndList, BOOL fListBox, LPSTR lpszTTFaceName, INT CodePage) { LPTSTR pszBuf; LPTSTR pszBufNew; LPTSTR psz; LPTSTR lpszNext; DWORD dwHWReq; DWORD dwHWActual; BOOL fSuccess; DWORD cchBuf; DWORD cchActual; int i; int idx = IsBilingualCP(CodePage) ? 1 : 0; /* * See if we can load everything out of the szTTCacheSection. * * There is no API to get the size of a profile string, so we * have to fake it by reading, reallocing, and reading again * until it all fits. * * The initial value of 1024 characters means that we can handle * up to 128 font sizes. A comfortable number, we hope. */ cchBuf = 1024; cchActual = 0; pszBufNew = (LPTSTR)LocalAlloc(LPTR, cchBuf*sizeof(TCHAR)); while (pszBufNew) { pszBuf = pszBufNew; cchActual = GetPrivateProfileString(szTTCacheSection[idx], NULL, c_szNULL, pszBuf, cchBuf, szSystemINI); if (cchActual < cchBuf - 5) goto Okay; cchBuf += 512; pszBufNew = (LPTSTR)LocalReAlloc(pszBuf, cchBuf*sizeof(TCHAR), LMEM_MOVEABLE|LMEM_ZEROINIT); } /* Bleargh. Too much stuff in the cache. Punt it and start anew. */ goto FreshStart; Okay: fSuccess = FALSE; /* * In the time between flushing the cache and reloading it here, * a handful of fonts may have gotten added to the cache due to * WinOldAp trying to realize the font it got back. So consider the * font cache decent if there are at least ten fonts in it. */ if (cchActual >= 4 * 10) { /* * We found cache information. Party away. */ psz = pszBuf; while (*psz) { if (ParseIniWords(psz, (PWORD)&dwHWReq, 2, &lpszNext) != 2 || GetIniWords(szTTCacheSection[idx], psz, (PWORD)&dwHWActual, 2, szSystemINI) != 2) { /* Font cache looks bogus. Start with a new one. */ goto FreshStart; } if (AddToFontListCache(hwndList, fListBox, (UINT)HIWORD(dwHWReq), (UINT)LOWORD(dwHWReq), (UINT)HIWORD(dwHWActual), (UINT)LOWORD(dwHWActual), CodePage) == BPFDI_CANCEL) goto E0; psz = (LPTSTR)(lpszNext + 1); /* Skip past the NUL */ } } else { FreshStart: /* Blast the old cache, just make sure we have a clean slate */ WritePrivateProfileString(szTTCacheSection[idx], NULL, NULL, szSystemINI); /* No cache available. Need to build one. */ for (i = 0; i < NUMINITIALTTHEIGHTS; i++) { if (rgwInitialTtHeights[i]) { AddOneNewTrueTypeFontToFontListA(hwndList, fListBox, 0, (UINT)rgwInitialTtHeights[i], lpszTTFaceName, CodePage); } } } fSuccess = TRUE; E0: EVAL(LocalFree(pszBuf) == NULL); return fSuccess; } /* Given height and width, synthesize a TrueType font with those * dimensions and record the actual font height and width in * the persistent font cache, as well as a FDI. * * Entry: * hwndList = List box or combo box to fill with info * fListBox = TRUE if hwndList is a listbox, FALSE if a combo box * wHeight = Desired font height * wWidth = Desired font width (can be zero for "default") * lpszTTFaceName * * Returns: * BPFDI of font dimension info, or BPFDI_CANCEL on failure. * * Caveats: * The wsprintf assumes that the fdiWidthReq and * fdiHeightReq fields appear in the indicated order, * because the values will be read into a dwHeightWidth later. * * Similarly for the WriteIniWords. */ BPFDI AddOneNewTrueTypeFontToFontListA(HWND hwndList, BOOL fListBox, UINT uWidth, UINT uHeight, LPSTR lpszTTFaceName, INT CodePage) { BPFDI bpfdi; HDC hDC; HFONT hFont; SIZE sSize; HFONT hFontPrev; DWORD dwHeightWidth; TCHAR szBuf[MAXDIMENSTRING]; int idx; BYTE bCharset; DWORD fdwClipPrecision; bpfdi = BPFDI_CANCEL; hDC = GetDC(NULL); /* Get a screen DC */ if (!hDC) goto E0; // choose charset, clip precision based on codepage // 0xFE is a hack for japanese platform // bCharset = (CodePage == CP_JPN? 0xFE: OEMCharsetFromCP(CodePage)); if (CodePage == CP_US) fdwClipPrecision = CLIP_DEFAULT_PRECIS|(g_uCodePage == CP_WANSUNG? CLIP_DFA_OVERRIDE: 0); else fdwClipPrecision = CLIP_DEFAULT_PRECIS; hFont = CreateFontA((INT)uHeight, (INT)uWidth, 0, 0, 0, 0, 0, 0, bCharset, OUT_TT_PRECIS, fdwClipPrecision, 0, FIXED_PITCH | FF_DONTCARE, lpszTTFaceName); if (!hFont) goto E1; hFontPrev = SelectObject(hDC, hFont); if (!hFontPrev) goto E2; if (GetTextExtentPoint32(hDC, szZero, 1, &sSize)) { dwHeightWidth = (sSize.cy << 16) | (sSize.cx & 0x00FF); } else { dwHeightWidth = 0; } if (!dwHeightWidth) goto E3; if (IsBilingualCP(CodePage) && (HIWORD(dwHeightWidth)%2)) goto E3; wsprintf(szBuf, TEXT("%d %d"), uWidth, uHeight); idx = IsBilingualCP(CodePage) ? 0 : 1; WriteIniWords(szTTCacheSection[idx], szBuf, (PWORD)&dwHeightWidth, 2, szSystemINI); bpfdi = AddToFontListCache(hwndList, fListBox, uHeight, uWidth, (UINT)sSize.cy, (UINT)sSize.cx, CodePage); E3: SelectObject(hDC, hFontPrev); E2: DeleteObject(hFont); E1: ReleaseDC(0, hDC); E0: return bpfdi; } /* Returns the BPFDI corresponding to the currently selected font in * the indicated list or combo box, or BPFDI_CANCEL on error. * * Entry: * hwndList == handle to listbox or combo box to fill * if NULL, then AUTO font calculation is assumed * fListBox == TRUE if hwndList is a listbox, FALSE if a combo box * pfi -> FNTINFO structure * if pfi is NULL, then AUTO font calculation is ignored * Returns: * BPFDI of the current selection, or BPFDI_CANCEL on error. */ DWORD_PTR GetFont(HWND hwndList, BOOL fListBox, PFNTINFO pfi) { DWORD dwIndex = 0; BPFDI bpfdi = BPFDI_CANCEL; if (!hwndList) { // just do AUTO calculations if (!pfi) goto Exit; // whoops, can't even do those goto ChooseBest; } dwIndex = lcbGetCurSel(hwndList, fListBox); if (!IsDlgError(dwIndex)) { if (pfi) pfi->fntProposed.flFnt &= ~FNT_AUTOSIZE; bpfdi = lcbGetBpfdi(hwndList, fListBox, dwIndex); if (bpfdi == BPFDI_AUTO && pfi) { pfi->fntProposed.flFnt |= FNT_AUTOSIZE; ChooseBest: bpfdi = ChooseBestFont((UINT)pfi->winOriginal.cxCells, (UINT)pfi->winOriginal.cyCells, (UINT)pfi->winOriginal.cxClient, (UINT)pfi->winOriginal.cyClient, (UINT)pfi->fntProposed.flFnt, (INT)pfi->fntProposed.wCurrentCP); } // Set the index of the current selection (HIWORD // of the return code) to LB_ERR if there's an error if (bpfdi == BPFDI_CANCEL) dwIndex = (DWORD)LB_ERR; } Exit: if (!IsSpecialBpfdi(bpfdi)) { bpfdi->Index = dwIndex; } return (DWORD_PTR)bpfdi; } /* Copies data from the given BPFDI to the given PROPFNT structure. * * Entry: * lpFnt = pointer to PROPFNT structure * bpfdi = based pointer to a FONTDIMENINFO structure; * if a special BPFDI_* constant, no font info is changed * Returns: * Nothing */ void SetFont(LPPROPFNT lpFnt, BPFDI bpfdi) { if (!IsSpecialBpfdi(bpfdi)) { lpFnt->flFnt &= ~(FNT_RASTER | FNT_TT); if (bpfdi->fdiHeightReq == 0) { /* Raster font */ lpFnt->flFnt |= FNT_RASTER; lpFnt->cxFont = lpFnt->cxFontActual = (WORD) bpfdi->fdiWidthActual; lpFnt->cyFont = lpFnt->cyFontActual = (WORD) bpfdi->fdiHeightActual; } else { /* TrueType font */ lpFnt->flFnt |= FNT_TT; lpFnt->cxFont = (WORD) bpfdi->fdiWidthReq; lpFnt->cyFont = (WORD) bpfdi->fdiHeightReq; lpFnt->cxFontActual = (WORD) bpfdi->fdiWidthActual; lpFnt->cyFontActual = (WORD) bpfdi->fdiHeightActual; } } } /* Performs the following calculation in LONG arithmetic to avoid * overflow: * return = n1 * m / n2 * This can be used to make an aspect ration calculation where n1/n2 * is the aspect ratio and m is a known value. The return value will * be the value that corresponds to m with the correct apsect ratio. */ // // // /* Scales a point to be preview-sized instead of screen-sized. * Depends on the global vars cxScreen and cyScreen established at init. */ void AspectPoint(LPRECT lprcPreview, LPPOINT lppt) { lppt->x = AspectScale(lprcPreview->right, cxScreen, lppt->x); lppt->y = AspectScale(lprcPreview->bottom, cyScreen, lppt->y); } /* AspectRect * * Scales a rectangle to be preview-sized instead of screen-sized. * Depends on the global vars cxScreen and cyScreen established at init. */ void AspectRect(LPRECT lprcPreview, LPRECT lprc) { AspectPoint(lprcPreview, &((LPPOINT)lprc)[0]); /* Upper left corner */ AspectPoint(lprcPreview, &((LPPOINT)lprc)[1]); /* Lower right corner */ } /* Given a BPFDI, create a font that corresponds to it. * * Entry: * bpfdi -> FDI describing the font we want to create * pfi -> proposed font info structure * * Returns: * HFONT that was created. */ HFONT CreateFontFromBpfdi(BPFDI bpfdi, PFNTINFO pfi) { HFONT hf; int fdwClipPrecision; BYTE bT2Charset; // a hack for japanese charset bT2Charset = (pfi->fntProposed.wCurrentCP == CP_JPN? 0xFE: OEMCharsetFromCP(pfi->fntProposed.wCurrentCP)); if (pfi->fntProposed.wCurrentCP == CP_US) fdwClipPrecision = CLIP_DEFAULT_PRECIS|(g_uCodePage == CP_WANSUNG? CLIP_DFA_OVERRIDE: 0); else fdwClipPrecision = CLIP_DEFAULT_PRECIS; if (bpfdi->fdiHeightReq == 0) { /* Raster font */ hf = CreateFontA(bpfdi->fdiHeightActual, bpfdi->fdiWidthActual, 0, 0, 0, 0, 0, 0, (BYTE)OEMCharsetFromCP(pfi->fntProposed.wCurrentCP), OUT_RASTER_PRECIS, fdwClipPrecision, 0, FIXED_PITCH | FF_DONTCARE, pfi->fntProposed.achRasterFaceName); } else { /* a TrueType font */ hf = CreateFontA(bpfdi->fdiHeightReq, bpfdi->fdiWidthReq, 0, 0, 0, 0, 0, 0, (BYTE)bT2Charset, OUT_TT_PRECIS, fdwClipPrecision, 0, FIXED_PITCH | FF_DONTCARE, pfi->fntProposed.achTTFaceName); } return hf; } /** FontSelInit * * Obtain the various font selection penalties from SYSTEM.INI * and force the values into range. * * Entry: * rgwInitialTtHeights contains default values for sizes. * * Exit: * rgwInitialTtHeights contains actual values for sizes. */ void FontSelInit(void) { GetIniWords(szNonWinSection, szTTInitialSizes, rgwInitialTtHeights, sizeof(rgwInitialTtHeights)/sizeof(WORD), szSystemINI); } /* Convert logical dimensions for a TrueType font into physical * dimensions. If possible, we get this information from the * font dimension cache, but in the case where this is not possible, * we synthesize the font and measure him directly. * * Entry: * dxWidth = logical font width * dyHeight = logical font height * * Returns: * BPFDI pointing to dimension information, or BPFDI_CANCEL on failure. */ BPFDI GetTrueTypeFontTrueDimensions(UINT dxWidth, UINT dyHeight, INT CodePage) { IFDI ifdi; BPFDI bpfdi; int idx = IsBilingualCP(CodePage)? 1 : 0; for (ifdi = 0, bpfdi = (BPFDI)((DWORD_PTR)lpCache + bpfdiStart[idx]); ifdi < cfdiCache[idx]; ifdi++, bpfdi++) { if (bpfdi->fdiWidthReq == dxWidth && bpfdi->fdiHeightReq == dyHeight) { return bpfdi; } } /* * The font dimensions have not been cached. We have to create it. */ return (BPFDI)AddOneNewTrueTypeFontToFontListA(0, 0, dxWidth, dyHeight, szTTFaceName[idx], CodePage); } /* Look for a font that matches the indicated dimensions, creating * one if necessary. * * But we never create a font which is too narrow or too short. * The limits are controlled by the ptNonAspectMin variable. * * Entry: * dxWidth = desired font width * dyHeight = desired font height * fPerfect = see below * * If fPerfect is TRUE, then a perfect match is requested * from the font cache (we should not try to synthesize a font). * In which case, the sign of dyHeight determines whether a * raster font (positive) or TrueType font (negative) is * desired. If a perfect match cannot be found, then we * return BPFDI_CANCEL. * * Returns: * BPFDI of of the font that matches the best. * BPFDI_CANCEL if no font could be found. */ BPFDI FindFontMatch(UINT dxWidth, UINT dyHeight, LPINT lpfl, INT CodePage) { IFDI ifdi; BPFDI bpfdi; BPFDI bpfdiBest = BPFDI_CANCEL; PENALTY pnlBest = SENTINELPENALTY; int idx; int fl = *lpfl; /* * First, see if a perfect match already exists. */ idx = IsBilingualCP(CodePage) ? 1 : 0; for (ifdi = 0, bpfdi = (BPFDI)((DWORD_PTR)lpCache+bpfdiStart[idx]); ifdi < cfdiCache[idx]; ifdi++, bpfdi++) { if (fl & FFM_RESTRICTED) { /* Deal with the restrictions. * Reject the font if it is raster but we want TTONLY, or v.v. * * The condition below reads as * * If (is a raster font != want a raster font) */ if (!bpfdi->fdiHeightReq != (fl == FFM_RASTERFONTS)) { continue; } } if (bpfdi->fdiHeightActual == dyHeight && bpfdi->fdiWidthActual == dxWidth) { *lpfl = FFM_PERFECT; return bpfdi; } } if (fl != FFM_TTFONTS) return BPFDI_CANCEL; /* * We got here if we couldn't find a perfect match. * * Adjust the requested height and width for aspect ratio * constraints. If adjustments are necessary, trust the height. * * Comparisons are as WORDs (unsigned) so that a setting of "-1 -1" * lets the user forbid all non-aspect ratio fonts. */ if (dyHeight < (UINT)ptNonAspectMin.y || dxWidth < (UINT)ptNonAspectMin.x) { dxWidth = 0; } return GetTrueTypeFontTrueDimensions(dxWidth, dyHeight, CodePage); } /* We have decided whether the desired size is larger or smaller. * Compute the penalty corresponding to the Initial and Scale. * * Entry: * ppnlp -> PENALTYPAIR to apply * dSmaller = the smaller dimension * dLarger = the larger dimension * * Exit: * Returns penalty to apply to the difference in dimensions. */ PENALTY ComputePenaltyFromPair(PPENALTYPAIR ppnlp, UINT dSmaller, UINT dLarger) { return (ppnlp->pnlInitial + ppnlp->pnlScale - MulDiv(ppnlp->pnlScale, dSmaller, dLarger)); } /* Compute the penalty depending on whether the desired size * is smaller, equal to, or larger than the actual size. * * Entry: * ppnll -> PENALTYLIST to apply * dActual = the actual dimension * dDesired = the desired dimension * * Exit: * Returns penalty to apply to the difference in dimensions, * choosing between the Overshoot and Shortfall PENALTYPAIRS, * accordingly. */ PENALTY ComputePenaltyFromList(PPENALTYLIST ppnll, UINT dActual, UINT dDesired) { if (dActual == dDesired) return 0; if (dActual < dDesired) return ComputePenaltyFromPair(&ppnll->pnlpOvershoot, dActual, dDesired); return ComputePenaltyFromPair(&ppnll->pnlpShortfall, dDesired, dActual); } /** ComputePenalty * * Compute the total penalty associated to a window size. * * Entry: * dxCells = width of window in cells * dyCells = height of window in cells * dxClient = actual horizontal size of window * dyClient = actual vertical size of window * dxFont = width of one character in the font * dyFont = height of one character in the font * * Exit: * Returns total penalty associated to a window of the indicated * size with a font of the indicated dimensions. */ PENALTY ComputePenalty(UINT cxCells, UINT cyCells, UINT dxClient, UINT dyClient, UINT dxFont, UINT dyFont) { return (ComputePenaltyFromList(&pnllX, dxClient, dxFont * cxCells) + ComputePenaltyFromList(&pnllY, dyClient, dyFont * cyCells)); } /** ChooseBestFont * * Determine which font looks best for the specified window size * by picking the one which has the smallest penalty. * * Entry: * dxCells = width of window in cells * dyCells = height of window in cells * dxClient= width of window we want to fit into * dyClient= height of window we want to fit into * fl = font pool flags * * Returns: * Word offset from lpFontTable of the font we've decided to use. * BPFDI_CANCEL if no font could be found. (Should never happen.) * * NOTE! * We do *not* FontEnum through all the fonts because that would be * too slow. Instead, we inspect the cache of available font * dimensions, and only after we've chosen the best font do we * load all his other info. * * This means that if the user installs new fonts, we won't see * them until the cache is updated on receipt of a WM_FONTCHANGEff * message, or the user either (1) pulls down the font list box, * or (2) calls up the font selection dialog box. */ BPFDI ChooseBestFont(UINT cxCells, UINT cyCells, UINT dxClient, UINT dyClient, INT fl, INT CodePage) { int flTemp; DWORD ifdi; BPFDI bpfdi; PENALTY pnl; UINT dxWidth, dyHeight; BPFDI bpfdiBest = BPFDI_CANCEL; PENALTY pnlBest = SENTINELPENALTY; int idx; static int prev_CodePage; // Only Japan is interested in prev_CodePage. /* * First, synthesize the theoretical best match. */ if (!cxCells) cxCells = 80; // if we get called with no real data, if (!cyCells) // at least try to do something reasonable cyCells = 25; // // In the case where the values passed in don't make sense, // we default to raster 8x12. // dxWidth = (dxClient >= cxCells)? dxClient / cxCells : 8; dyHeight = (dyClient >= cyCells)? dyClient / cyCells : 12; // // Now, if we bad values, make some sense out of bad values for // dxClient & dyClient // if ((dxClient==0) || (dyClient==0)) { dxClient = dxWidth * 80; dyClient = dyHeight * 25; } flTemp = 0; if ((fl & FNT_BOTHFONTS) != FNT_BOTHFONTS) { flTemp = FFM_RASTERFONTS; if (fl & FNT_TTFONTS) flTemp = FFM_TTFONTS; } bpfdi = FindFontMatch(dxWidth, dyHeight, &flTemp, CodePage); if (flTemp == FFM_PERFECT) { prev_CodePage = CodePage; return bpfdi; } idx = IsBilingualCP(CodePage)? 1 : 0; for (ifdi = 0, bpfdi = (BPFDI)((DWORD_PTR)lpCache+bpfdiStart[idx]); ifdi < cfdiCache[idx]; ifdi++, bpfdi++) { // If the font pool is restricted, then only look at like fonts if (flTemp) if (!bpfdi->fdiHeightReq != (flTemp == FFM_RASTERFONTS)) continue; // was ifdef JAPAN (hack) // to prevent DOS_BOX shrinking which occurs toggling CP437 & CP932, // just select one size bigger font when change CP437 to CP932 if (CodePage == 932 && prev_CodePage == 437) { if (dxWidth < bpfdi->fdiWidthActual) { if (bpfdiBest->fdiWidthActual > bpfdi->fdiWidthActual) bpfdiBest = bpfdi; else if (bpfdiBest->fdiWidthActual == bpfdi->fdiWidthActual && bpfdiBest->fdiHeightActual > bpfdi->fdiHeightActual) bpfdiBest = bpfdi; } else { if (dxWidth == bpfdi->fdiWidthActual) { if (bpfdi->fdiHeightActual > dyHeight && bpfdiBest->fdiHeightActual > bpfdi->fdiHeightActual) bpfdiBest = bpfdi; } } } else // was the end of ifdef JAPAN { pnl = 0; if (bpfdi->fdiHeightReq) pnl = pnlTrueType; pnl += ComputePenalty(cxCells, cyCells, dxClient, dyClient, bpfdi->fdiWidthActual, bpfdi->fdiHeightActual); if (pnl <= pnlBest) { pnlBest = pnl; bpfdiBest = bpfdi; } } } // was ifdef JAPAN prev_CodePage = CodePage; // was end of ifdef JAPAN return bpfdiBest; }