674 lines
23 KiB
C
674 lines
23 KiB
C
/* NC.C
|
|
Resident Code Segment // Tweak: make non-resident?
|
|
|
|
Routines for reading and writing Non-client metrics, and icons.
|
|
|
|
Roughly: Borders and Fonts and Icons stuff.
|
|
|
|
GatherIconMetricsByHand();
|
|
GatherNonClientMetricsByHand();
|
|
SetIconMetricsByHand();
|
|
SetNonClientMetricsByHand();
|
|
|
|
Unlike all of the other items, we do not read and write these to the
|
|
registry directly. Instead, we use the SystemParametersInfo(GET/SET)
|
|
API.
|
|
|
|
***
|
|
This is a low-header-comment file. The four functions just read and write
|
|
two sets of params. Comments within the functions show the simple goings-
|
|
on.
|
|
|
|
Uses: global pValue buffer from REGUTILS.C
|
|
***
|
|
|
|
Frosting: Master Theme Selector for Windows '95
|
|
Copyright (c) 1994-1999 Microsoft Corporation. All rights reserved.
|
|
*/
|
|
|
|
// ---------------------------------------------
|
|
// Brief file history:
|
|
// Alpha:
|
|
// Beta:
|
|
// Bug fixes
|
|
// ---------
|
|
//
|
|
// ---------------------------------------------
|
|
|
|
#include "windows.h"
|
|
#include <mbctype.h>
|
|
#include "frost.h"
|
|
#include "nc.h"
|
|
|
|
|
|
////////////////////////////////////////////////
|
|
//
|
|
// E X T E R N A L F U N C T I O N S
|
|
//
|
|
// Uses external functions in REGUTILS.C,
|
|
// which was going to be the only function to
|
|
// read and write -- until we found we couldn't
|
|
// do these parameters live directly to the registry.
|
|
//
|
|
////////////////////////////////////////////////
|
|
extern BOOL FAR WriteBytesToFile(LPTSTR, LPTSTR, BYTE *, int, LPTSTR);
|
|
extern int FAR WriteBytesToBuffer(LPTSTR);
|
|
|
|
//
|
|
// LOCAL ROUTINES
|
|
//
|
|
|
|
//
|
|
// LOCAL GLOBALS
|
|
extern BOOL bReadOK, bWroteOK;
|
|
|
|
|
|
////////////////////////////////////////////////
|
|
//
|
|
// FONTS and BORDERS and ICONS
|
|
//
|
|
// These are done by hand only!
|
|
// These are all read and set with SystemParametersInfo() instead of reading
|
|
// and writing directly to the registry like the naughty app we are with most
|
|
// of the above.
|
|
//
|
|
|
|
// General
|
|
TCHAR szMetrics[] = TEXT("Metrics");
|
|
TCHAR szNCM[] = TEXT("NonclientMetrics");
|
|
TCHAR szIM[] = TEXT("IconMetrics");
|
|
|
|
TCHAR szCP_DT_WM[] = TEXT("Control Panel\\Desktop\\WindowMetrics");
|
|
TCHAR szIconSize[] = TEXT("Shell Icon Size");
|
|
TCHAR szSmallIconSize[] = TEXT("Shell Small Icon Size");
|
|
|
|
#ifdef FOO
|
|
// BORDERS
|
|
TCHAR szBorderWidth[] = TEXT("BorderWidth");
|
|
TCHAR szScrollWidth[] = TEXT("ScrollWidth");
|
|
TCHAR szScrollHeight[] = TEXT("ScrollHeight");
|
|
TCHAR szCapWidth[] = TEXT("CaptionWidth");
|
|
TCHAR szCapHeight[] = TEXT("CaptionHeight");
|
|
TCHAR szSmCapWidth[] = TEXT("SmCaptionWidth");
|
|
TCHAR szSmCapHeight[] = TEXT("SmCaptionHeight");
|
|
TCHAR szMenuWidth[] = TEXT("MenuWidth");
|
|
TCHAR szMenuHeight[] = TEXT("MenuHeight");
|
|
|
|
// FONTS styles and names and sizes mixed together
|
|
TCHAR szCapFont[] = TEXT("CaptionFont");
|
|
TCHAR szSmCapFont[] = TEXT("SmCaptionFont");
|
|
TCHAR szMenuFont[] = TEXT("MenuFont");
|
|
TCHAR szStatFont[] = TEXT("StatusFont");
|
|
TCHAR szMsgFont[] = TEXT("MessageFont");
|
|
|
|
// ICONS
|
|
TCHAR szIconFont[] = TEXT("IconFont");
|
|
TCHAR szIconVertSpacing[] = TEXT("IconVertSpacing");
|
|
TCHAR szIconHorzSpacing[] = TEXT("IconHorzSpacing");
|
|
#endif
|
|
|
|
|
|
// These two are in the registry, but do not correspond to
|
|
// anything in the Display CPL or SystemParametersInfo() code.
|
|
// I assume that these are set internally by the system
|
|
// based on the icon size (set directly in the registry earlier)
|
|
// and horz/vert spacing (set right above). DB will test
|
|
// and if it works for his themes, then we're there.
|
|
// "IconSpacing";
|
|
// "IconSpacingFactor";
|
|
|
|
// Later added these two by hand, in and out of reg, so can
|
|
// check for null values.
|
|
//
|
|
// {TEXT("Shell Icon Size"), REG_SZ, FC_ICONS},
|
|
// {TEXT("Shell Small Icon Size"), REG_SZ, FC_ICONS},
|
|
|
|
|
|
BOOL FAR GatherIconMetricsByHand(LPTSTR lpszTheme)
|
|
{
|
|
ICONMETRICS im;
|
|
// BOOL bOK, bret;
|
|
BOOL bOK;
|
|
extern BOOL bReadOK, bWroteOK;
|
|
#ifdef UNICODE
|
|
#ifdef FUDDY_DUDDY
|
|
CHAR szTempA[10];
|
|
#endif
|
|
ICONMETRICSA imA;
|
|
#endif
|
|
|
|
// inits
|
|
im.cbSize = sizeof(im);
|
|
bOK = SystemParametersInfo(SPI_GETICONMETRICS, sizeof(im),
|
|
(void far *)(LPICONMETRICS)&im, FALSE);
|
|
if (!bOK) bReadOK = FALSE;
|
|
|
|
// write the whole kit and kaboodle
|
|
|
|
#ifdef UNICODE
|
|
// Need to convert the ICONMETRICS structure to ANSI before writing
|
|
// to the Theme file.
|
|
ConvertIconMetricsToANSI((LPICONMETRICSW)&im, (LPICONMETRICSA)&imA);
|
|
|
|
if (bOK) {
|
|
bOK = WriteBytesToFile((LPTSTR)szMetrics, (LPTSTR)szIM,
|
|
(BYTE *)&(imA), sizeof(ICONMETRICSA), lpszTheme);
|
|
}
|
|
#else
|
|
// Currently ANSI so no need to convert ICONMETRICS before writing
|
|
// to Theme file
|
|
|
|
if (bOK) {
|
|
bOK = WriteBytesToFile((LPTSTR)szMetrics, (LPTSTR)szIM,
|
|
(BYTE *)&(im), sizeof(ICONMETRICS), lpszTheme);
|
|
}
|
|
#endif // UNICODE
|
|
|
|
if (!bOK) bWroteOK = FALSE;
|
|
|
|
#ifdef DOING_ICON_SIZES
|
|
//
|
|
// now get and store icon sizes
|
|
|
|
// first Icon Size
|
|
bret = HandGet(HKEY_CURRENT_USER, szCP_DT_WM,
|
|
szIconSize, (LPTSTR)pValue);
|
|
Assert(bret, TEXT("couldn't get IconSize from Registry!\n"));
|
|
bOK = bOK && bret;
|
|
bret = WritePrivateProfileString((LPTSTR)szCP_DT_WM, (LPTSTR)szIconSize,
|
|
// only store if got something, else null
|
|
(LPTSTR)(bret ? pValue : szNULL),
|
|
lpszTheme);
|
|
bOK = bOK && bret;
|
|
if (!bret) bWroteOK = FALSE;
|
|
|
|
// then Small Icon Size
|
|
bret = HandGet(HKEY_CURRENT_USER, szCP_DT_WM,
|
|
szSmallIconSize, (LPTSTR)pValue);
|
|
Assert(bret, TEXT("couldn't get SmallIconSize from Registry!\n"));
|
|
bOK = bOK && bret;
|
|
bret = WritePrivateProfileString((LPTSTR)szCP_DT_WM, (LPTSTR)szSmallIconSize,
|
|
// only store if got something, else null
|
|
(LPTSTR)(bret ? pValue : szNULL),
|
|
lpszTheme);
|
|
bOK = bOK && bret;
|
|
if (!bret) bWroteOK = FALSE;
|
|
#endif // DOING_ICON_SIZES
|
|
|
|
|
|
#ifdef FUDDY_DUDDY
|
|
// 3 writes: translate to string and write to THM file
|
|
if (bOK) {
|
|
|
|
// write font to theme file
|
|
// REARCHITECT: if we were really doing this you would want to convert
|
|
// this LOGFONT to ANSI before writing to the Theme file.
|
|
bRet = WriteBytesToFile((LPTSTR)szMetrics, (LPTSTR)szIconFont,
|
|
(BYTE *)&(im.lfFont), sizeof(LOGFONT), lpszTheme);
|
|
bOK = bOK && bRet;
|
|
|
|
// write vert spacing to theme file
|
|
#ifdef UNICODE
|
|
litoa(im.iVertSpacing, szTempA);
|
|
mbstowcs(pValue, szTempA, sizeof(szTempA));
|
|
#else
|
|
litoa(im.iVertSpacing, (LPTSTR)pValue);
|
|
#endif
|
|
bRet = WritePrivateProfileString((LPTSTR)szMetrics, (LPTSTR)szIconVertSpacing,
|
|
(LPTSTR)pValue, lpszTheme);
|
|
|
|
bOK = bOK && bRet;
|
|
|
|
// write horz spacing to theme file
|
|
#ifdef UNICODE
|
|
litoa(im.iHorzSpacing, szTempA);
|
|
mbstowcs(pValue, szTempA, sizeof(szTempA));
|
|
#else
|
|
litoa(im.iHorzSpacing, (LPTSTR)pValue);
|
|
#endif
|
|
bRet = WritePrivateProfileString((LPTSTR)szMetrics, (LPTSTR)szIconHorzSpacing,
|
|
(LPTSTR)pValue, lpszTheme);
|
|
bOK = bOK && bRet;
|
|
}
|
|
#endif // FUDDY_DUDDY
|
|
|
|
// cleanup
|
|
Assert(bOK, TEXT("problem gathering icon metrics by hand\n"));
|
|
return (bOK);
|
|
}
|
|
|
|
BOOL FAR GatherNonClientMetricsByHand(LPTSTR lpszTheme)
|
|
{
|
|
NONCLIENTMETRICS ncm;
|
|
BOOL bOK;
|
|
#ifdef UNICODE
|
|
NONCLIENTMETRICSA ncmA;
|
|
#endif
|
|
|
|
// inits
|
|
ncm.cbSize = sizeof(ncm);
|
|
bOK = SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm),
|
|
(void far *)(LPNONCLIENTMETRICS)&ncm, FALSE);
|
|
if (!bOK) bReadOK = FALSE;
|
|
|
|
// write the whole kit and kaboodle
|
|
#ifdef UNICODE
|
|
// Need to convert the NONCLIENTMETRICS structure to ANSI before
|
|
// writing it to the Theme file
|
|
ConvertNCMetricsToANSI((LPNONCLIENTMETRICSW)&ncm, (LPNONCLIENTMETRICSA)&ncmA);
|
|
|
|
if (bOK) {
|
|
bOK = WriteBytesToFile((LPTSTR)szMetrics, (LPTSTR)szNCM,
|
|
(BYTE *)&(ncmA), sizeof(NONCLIENTMETRICSA), lpszTheme);
|
|
}
|
|
#else
|
|
// No UNICODE so no need to convert NONCLIENTMETRICS to ANSI
|
|
// before writing to Theme file.
|
|
|
|
if (bOK) {
|
|
bOK = WriteBytesToFile((LPTSTR)szMetrics, (LPTSTR)szNCM,
|
|
(BYTE *)&(ncm), sizeof(NONCLIENTMETRICS), lpszTheme);
|
|
}
|
|
#endif // UNICODE
|
|
|
|
if (!bOK) bWroteOK = FALSE;
|
|
|
|
// cleanup
|
|
Assert(bOK, TEXT("problem gathering nonclient metrics by hand\n"));
|
|
return (bOK);
|
|
}
|
|
|
|
//
|
|
// SetIconMetricsByHand
|
|
//
|
|
// When they decided that icon fonts went with fonts not with
|
|
// icons, this got a little tangled. Follow the bools.
|
|
//
|
|
VOID FAR SetIconMetricsByHand(BOOL bIconSpacing, BOOL bIconFont)
|
|
{
|
|
UINT uret;
|
|
ICONMETRICS imCur, imStored;
|
|
LONG lret;
|
|
HKEY hKey;
|
|
|
|
//
|
|
// INITS
|
|
|
|
//
|
|
// Get cur iconmetrics
|
|
imCur.cbSize = sizeof(imCur);
|
|
uret = (UINT) SystemParametersInfo(SPI_GETICONMETRICS, sizeof(imCur),
|
|
(void far *)(LPICONMETRICS)&imCur, FALSE);
|
|
Assert(uret, TEXT("problem getting cur icon metrics before setting\n"));
|
|
|
|
//
|
|
// Get stored iconmetrics
|
|
|
|
// get stored data string
|
|
uret = (UINT) GetPrivateProfileString((LPTSTR)szMetrics, (LPTSTR)szIM,
|
|
(LPTSTR)szNULL,
|
|
(LPTSTR)pValue, MAX_VALUELEN,
|
|
(LPTSTR)szCurThemeFile);
|
|
Assert(uret, TEXT("problem getting stored icon metrics before setting\n"));
|
|
|
|
// if we somehow come up with no icon metrics in the theme, just
|
|
// PUNT and leave cur settings
|
|
if (*pValue) { // if something there to set
|
|
// translate stored data string to ICONMETRICS bytes
|
|
WriteBytesToBuffer((LPTSTR)pValue); // char str read from and binary bytes
|
|
// written to pValue. It's OK.
|
|
// get it into ICONMETRICS structure for ease of use and safety
|
|
#ifdef UNICODE
|
|
// ICONMETRICS are stored in ANSI format in the Theme file so if
|
|
// we're living in a UNICODE world we need to convert from ANSI
|
|
// to UNICODE
|
|
ConvertIconMetricsToWIDE((LPICONMETRICSA)pValue, (LPICONMETRICSW)&imStored);
|
|
#else
|
|
// No UNICODE, no need to convert from ANSI...
|
|
imStored = *((LPICONMETRICS)pValue);
|
|
#endif
|
|
//
|
|
// Combine the cur and the saved here and now in the imStored struct
|
|
imCur.cbSize = sizeof(ICONMETRICS); // paranoid
|
|
if (bIconSpacing) {
|
|
imCur.iHorzSpacing = imStored.iHorzSpacing;
|
|
imCur.iVertSpacing = imStored.iVertSpacing;
|
|
}
|
|
// iTitleWrap already as was in system
|
|
if (bIconFont)
|
|
imCur.lfFont = imStored.lfFont;
|
|
|
|
//
|
|
// Set it in the system live
|
|
uret = (UINT) SystemParametersInfo(SPI_SETICONMETRICS, sizeof(imCur),
|
|
(void far *)(LPICONMETRICS)&imCur,
|
|
// send change at end of theme application
|
|
SPIF_UPDATEINIFILE);
|
|
Assert(uret, TEXT("problem setting icon metrics in cur system!!\n"));
|
|
}
|
|
|
|
// the rest is just for icon size and spacing
|
|
if (bIconSpacing) {
|
|
//
|
|
// now do icon sizes directly to the registry
|
|
|
|
// open
|
|
lret = RegOpenKeyEx(HKEY_CURRENT_USER, szCP_DT_WM,
|
|
(DWORD)0, KEY_SET_VALUE, (PHKEY)&hKey );
|
|
if (lret == ERROR_SUCCESS) {
|
|
|
|
GetPrivateProfileString((LPTSTR)szCP_DT_WM, (LPTSTR)szIconSize,
|
|
(LPTSTR)szNULL,
|
|
(LPTSTR)pValue, MAX_VALUELEN, (LPTSTR)szCurThemeFile);
|
|
if (*pValue) { // non-null size settings only!
|
|
RegSetValueEx(hKey, (LPTSTR)szIconSize,
|
|
0,
|
|
(DWORD)REG_SZ,
|
|
(LPBYTE)pValue,
|
|
(DWORD)(SZSIZEINBYTES((LPTSTR)pValue) + 1));
|
|
}
|
|
|
|
GetPrivateProfileString((LPTSTR)szCP_DT_WM, (LPTSTR)szSmallIconSize,
|
|
(LPTSTR)szNULL,
|
|
(LPTSTR)pValue, MAX_VALUELEN, (LPTSTR)szCurThemeFile);
|
|
if (*pValue) { // non-null size settings only!
|
|
RegSetValueEx(hKey, (LPTSTR)szSmallIconSize,
|
|
0,
|
|
(DWORD)REG_SZ,
|
|
(LPBYTE)pValue,
|
|
(DWORD)(SZSIZEINBYTES((LPTSTR)pValue) + 1 ));
|
|
}
|
|
|
|
// cleanup!
|
|
RegCloseKey(hKey);
|
|
|
|
} // end if opened key
|
|
} // end if bIconSpacing
|
|
}
|
|
|
|
|
|
//
|
|
// SetNonClientMetricsByHand
|
|
//
|
|
// Borders and fonts are both in the same NONCLIENTMETRICS setting,
|
|
// so we have to set them together. Here's what we do:
|
|
// Start with cur system settings as default. If we are changing
|
|
// font styles, alter the fonts from the default. If we are changing
|
|
// window border and font sizes, make those changes to our default copy of
|
|
// the metrics and fonts, too.
|
|
//
|
|
// Then go reset the system.
|
|
//
|
|
VOID FAR SetNonClientMetricsByHand(BOOL bFonts, BOOL bBorders)
|
|
{
|
|
UINT uret;
|
|
NONCLIENTMETRICS ncmCur, ncmStored;
|
|
|
|
//
|
|
// INITS
|
|
|
|
//
|
|
// Get cur nonclientmetrics: this is the default until we hear otherwise
|
|
ncmCur.cbSize = sizeof(ncmCur);
|
|
uret = (UINT) SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncmCur),
|
|
(void far *)(LPNONCLIENTMETRICS)&ncmCur, FALSE);
|
|
Assert(uret, TEXT("problem getting cur nonclient metrics before setting\n"));
|
|
|
|
//
|
|
// Get stored nonclientmetrics
|
|
|
|
// get stored data string
|
|
uret = (UINT) GetPrivateProfileString((LPTSTR)szMetrics, (LPTSTR)szNCM,
|
|
(LPTSTR)szNULL,
|
|
(LPTSTR)pValue, MAX_VALUELEN,
|
|
(LPTSTR)szCurThemeFile);
|
|
Assert(uret, TEXT("problem getting stored nonclient metrics before setting\n"));
|
|
|
|
|
|
// if we somehow come up with no non-client metrics in the theme, just
|
|
// PUNT and leave cur settings
|
|
if (!(*pValue))
|
|
return; // easy no work to do EXIT
|
|
|
|
|
|
// translate stored data string to NONCLIENTMETRICS bytes
|
|
WriteBytesToBuffer((LPTSTR)pValue); // char str read from and binary bytes
|
|
// written to pValue. It's OK.
|
|
// get it into NONCLIENTMETRICS structure for ease of use and safety
|
|
#ifdef UNICODE
|
|
// NONCLIENTMETRICS are stored in ANSI format in the Theme file so
|
|
// we need to convert them to UNICODE
|
|
ConvertNCMetricsToWIDE((LPNONCLIENTMETRICSA)pValue, (LPNONCLIENTMETRICSW)&ncmStored);
|
|
#else
|
|
// No UNICODE so no need to convert NONCLIENTMETRICS...
|
|
ncmStored = *((LPNONCLIENTMETRICS)pValue);
|
|
#endif
|
|
//
|
|
// Combine the cur with the requested saved info here and now
|
|
// Cur metrics are the default, overridden for fields requested
|
|
// by user by new info from metrics stored with the theme.
|
|
//
|
|
// init
|
|
ncmCur.cbSize = sizeof(NONCLIENTMETRICS); // paranoid
|
|
|
|
// what we reset if the user checks Font names and styles
|
|
if (bFonts) {
|
|
// only (some) font information
|
|
TransmitFontCharacteristics(&(ncmCur.lfCaptionFont), &(ncmStored.lfCaptionFont),
|
|
TFC_STYLE);
|
|
TransmitFontCharacteristics(&(ncmCur.lfSmCaptionFont), &(ncmStored.lfSmCaptionFont),
|
|
TFC_STYLE);
|
|
TransmitFontCharacteristics(&(ncmCur.lfMenuFont), &(ncmStored.lfMenuFont),
|
|
TFC_STYLE);
|
|
TransmitFontCharacteristics(&(ncmCur.lfStatusFont), &(ncmStored.lfStatusFont),
|
|
TFC_STYLE);
|
|
TransmitFontCharacteristics(&(ncmCur.lfMessageFont), &(ncmStored.lfMessageFont),
|
|
TFC_STYLE);
|
|
}
|
|
|
|
// what we reset if the user checks Font and window si&zes
|
|
if (bBorders) {
|
|
// fonts
|
|
TransmitFontCharacteristics(&(ncmCur.lfCaptionFont), &(ncmStored.lfCaptionFont),
|
|
TFC_SIZE);
|
|
TransmitFontCharacteristics(&(ncmCur.lfSmCaptionFont), &(ncmStored.lfSmCaptionFont),
|
|
TFC_SIZE);
|
|
TransmitFontCharacteristics(&(ncmCur.lfMenuFont), &(ncmStored.lfMenuFont),
|
|
TFC_SIZE);
|
|
TransmitFontCharacteristics(&(ncmCur.lfStatusFont), &(ncmStored.lfStatusFont),
|
|
TFC_SIZE);
|
|
TransmitFontCharacteristics(&(ncmCur.lfMessageFont), &(ncmStored.lfMessageFont),
|
|
TFC_SIZE);
|
|
// window elements sizes
|
|
ncmCur.iBorderWidth = ncmStored.iBorderWidth;
|
|
ncmCur.iScrollWidth = ncmStored.iScrollWidth;
|
|
ncmCur.iScrollHeight = ncmStored.iScrollHeight;
|
|
ncmCur.iCaptionWidth = ncmStored.iCaptionWidth;
|
|
ncmCur.iCaptionHeight = ncmStored.iCaptionHeight;
|
|
ncmCur.iSmCaptionWidth = ncmStored.iSmCaptionWidth;
|
|
ncmCur.iSmCaptionHeight = ncmStored.iSmCaptionHeight;
|
|
ncmCur.iMenuWidth = ncmStored.iMenuWidth;
|
|
ncmCur.iMenuHeight = ncmStored.iMenuHeight;
|
|
}
|
|
|
|
//
|
|
// Phew! Now set it in the system live...
|
|
uret = (UINT) SystemParametersInfo(SPI_SETNONCLIENTMETRICS, sizeof(ncmCur),
|
|
(void far *)(LPNONCLIENTMETRICS)&ncmCur,
|
|
// send change at end of theme application
|
|
SPIF_UPDATEINIFILE);
|
|
Assert(uret, TEXT("problem setting nonclient metrics in cur system!!\n"));
|
|
}
|
|
|
|
|
|
//
|
|
// TransmitFontCharacteristics
|
|
//
|
|
// This is actually a pretty key function. See, font characteristics are
|
|
// all set together: a LOGFONT has name and style and size info all in one.
|
|
// But when you are setting all the nonclient metrics like window caption
|
|
// and menu size, you need to stretch the font sizes with it. But we give the
|
|
// user a choice of changing window sizes without "changing" the font; i.e.
|
|
// without applying a new font name and style from the theme.
|
|
//
|
|
// So we need to be able to pick apart the name and style from the size
|
|
// characteristics. And here it is.
|
|
//
|
|
// Really just a helper routine for the above function, so we don't have all
|
|
// this gunk inline five times.
|
|
//
|
|
VOID TransmitFontCharacteristics(PLOGFONT plfDst, PLOGFONT plfSrc, int iXmit)
|
|
{
|
|
switch (iXmit) {
|
|
case TFC_SIZE:
|
|
plfDst->lfHeight = plfSrc->lfHeight;
|
|
plfDst->lfWidth = plfSrc->lfWidth;
|
|
break;
|
|
case TFC_STYLE:
|
|
plfDst->lfEscapement = plfSrc->lfEscapement;
|
|
plfDst->lfOrientation = plfSrc->lfOrientation;
|
|
plfDst->lfWeight = plfSrc->lfWeight;
|
|
plfDst->lfItalic = plfSrc->lfItalic;
|
|
plfDst->lfUnderline = plfSrc->lfUnderline;
|
|
plfDst->lfStrikeOut = plfSrc->lfStrikeOut;
|
|
plfDst->lfCharSet = plfSrc->lfCharSet;
|
|
plfDst->lfOutPrecision = plfSrc->lfOutPrecision;
|
|
plfDst->lfClipPrecision = plfSrc->lfClipPrecision;
|
|
plfDst->lfQuality = plfSrc->lfQuality;
|
|
plfDst->lfPitchAndFamily = plfSrc->lfPitchAndFamily;
|
|
lstrcpy((LPTSTR)plfDst->lfFaceName,
|
|
(LPTSTR)plfSrc->lfFaceName);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
|
|
VOID ConvertIconMetricsToANSI(LPICONMETRICS wIM, LPICONMETRICSA aIM)
|
|
{
|
|
ZeroMemory(aIM, sizeof(aIM));
|
|
|
|
aIM->cbSize = sizeof(aIM);
|
|
aIM->iHorzSpacing = wIM->iHorzSpacing;
|
|
aIM->iVertSpacing = wIM->iVertSpacing;
|
|
aIM->iTitleWrap = wIM->iTitleWrap;
|
|
ConvertLogFontToANSI(&wIM->lfFont, &aIM->lfFont);
|
|
|
|
return;
|
|
}
|
|
|
|
VOID ConvertIconMetricsToWIDE(LPICONMETRICSA aIM, LPICONMETRICSW wIM)
|
|
{
|
|
ZeroMemory(wIM, sizeof(wIM));
|
|
|
|
wIM->cbSize = sizeof(wIM);
|
|
wIM->iHorzSpacing = aIM->iHorzSpacing;
|
|
wIM->iVertSpacing = aIM->iVertSpacing;
|
|
wIM->iTitleWrap = aIM->iTitleWrap;
|
|
ConvertLogFontToWIDE(&aIM->lfFont, &wIM->lfFont);
|
|
|
|
return;
|
|
}
|
|
|
|
VOID ConvertNCMetricsToANSI(LPNONCLIENTMETRICSW wNCM, LPNONCLIENTMETRICSA aNCM)
|
|
{
|
|
ZeroMemory(aNCM, sizeof(aNCM));
|
|
|
|
aNCM->cbSize = sizeof(aNCM);
|
|
aNCM->iBorderWidth = wNCM->iBorderWidth;
|
|
aNCM->iScrollWidth = wNCM->iScrollWidth;
|
|
aNCM->iScrollHeight = wNCM->iScrollHeight;
|
|
aNCM->iCaptionWidth = wNCM->iCaptionWidth;
|
|
aNCM->iCaptionHeight = wNCM->iCaptionHeight;
|
|
ConvertLogFontToANSI(&wNCM->lfCaptionFont, &aNCM->lfCaptionFont);
|
|
aNCM->iSmCaptionWidth = wNCM->iSmCaptionWidth;
|
|
aNCM->iSmCaptionHeight = wNCM->iSmCaptionHeight;
|
|
ConvertLogFontToANSI(&wNCM->lfSmCaptionFont, &aNCM->lfSmCaptionFont);
|
|
aNCM->iMenuWidth = wNCM->iMenuWidth;
|
|
aNCM->iMenuHeight = wNCM->iMenuHeight;
|
|
ConvertLogFontToANSI(&wNCM->lfMenuFont, &aNCM->lfMenuFont);
|
|
ConvertLogFontToANSI(&wNCM->lfStatusFont, &aNCM->lfStatusFont);
|
|
ConvertLogFontToANSI(&wNCM->lfMessageFont, &aNCM->lfMessageFont);
|
|
|
|
return;
|
|
}
|
|
|
|
VOID ConvertNCMetricsToWIDE(LPNONCLIENTMETRICSA aNCM, LPNONCLIENTMETRICSW wNCM)
|
|
{
|
|
ZeroMemory(wNCM, sizeof(wNCM));
|
|
|
|
wNCM->cbSize = sizeof(wNCM);
|
|
wNCM->iBorderWidth = aNCM->iBorderWidth;
|
|
wNCM->iScrollWidth = aNCM->iScrollWidth;
|
|
wNCM->iScrollHeight = aNCM->iScrollHeight;
|
|
wNCM->iCaptionWidth = aNCM->iCaptionWidth;
|
|
wNCM->iCaptionHeight = aNCM->iCaptionHeight;
|
|
ConvertLogFontToWIDE(&aNCM->lfCaptionFont, &wNCM->lfCaptionFont);
|
|
wNCM->iSmCaptionWidth = aNCM->iSmCaptionWidth;
|
|
wNCM->iSmCaptionHeight = aNCM->iSmCaptionHeight;
|
|
ConvertLogFontToWIDE(&aNCM->lfSmCaptionFont, &wNCM->lfSmCaptionFont);
|
|
wNCM->iMenuWidth = aNCM->iMenuWidth;
|
|
wNCM->iMenuHeight = aNCM->iMenuHeight;
|
|
ConvertLogFontToWIDE(&aNCM->lfMenuFont, &wNCM->lfMenuFont);
|
|
ConvertLogFontToWIDE(&aNCM->lfStatusFont, &wNCM->lfStatusFont);
|
|
ConvertLogFontToWIDE(&aNCM->lfMessageFont, &wNCM->lfMessageFont);
|
|
|
|
return;
|
|
}
|
|
|
|
VOID ConvertLogFontToANSI(LPLOGFONTW wLF, LPLOGFONTA aLF)
|
|
{
|
|
UINT uCodePage;
|
|
|
|
uCodePage = _getmbcp();
|
|
|
|
ZeroMemory(aLF, sizeof(aLF));
|
|
aLF->lfHeight = wLF->lfHeight;
|
|
aLF->lfWidth = wLF->lfWidth;
|
|
aLF->lfEscapement = wLF->lfEscapement;
|
|
aLF->lfOrientation = wLF->lfOrientation;
|
|
aLF->lfWeight = wLF->lfWeight;
|
|
aLF->lfItalic = wLF->lfItalic;
|
|
aLF->lfUnderline = wLF->lfUnderline;
|
|
aLF->lfStrikeOut = wLF->lfStrikeOut;
|
|
aLF->lfCharSet = wLF->lfCharSet;
|
|
aLF->lfOutPrecision = wLF->lfOutPrecision;
|
|
aLF->lfClipPrecision = wLF->lfClipPrecision;
|
|
aLF->lfQuality = wLF->lfQuality;
|
|
aLF->lfPitchAndFamily = wLF->lfPitchAndFamily;
|
|
|
|
WideCharToMultiByte(uCodePage, 0, wLF->lfFaceName, -1,
|
|
aLF->lfFaceName, LF_FACESIZE, NULL, NULL);
|
|
|
|
return;
|
|
}
|
|
|
|
VOID ConvertLogFontToWIDE(LPLOGFONTA aLF, LPLOGFONTW wLF)
|
|
{
|
|
UINT uCodePage;
|
|
|
|
uCodePage = _getmbcp();
|
|
|
|
ZeroMemory(wLF, sizeof(wLF));
|
|
wLF->lfHeight = aLF->lfHeight;
|
|
wLF->lfWidth = aLF->lfWidth;
|
|
wLF->lfEscapement = aLF->lfEscapement;
|
|
wLF->lfOrientation = aLF->lfOrientation;
|
|
wLF->lfWeight = aLF->lfWeight;
|
|
wLF->lfItalic = aLF->lfItalic;
|
|
wLF->lfUnderline = aLF->lfUnderline;
|
|
wLF->lfStrikeOut = aLF->lfStrikeOut;
|
|
wLF->lfCharSet = aLF->lfCharSet;
|
|
wLF->lfOutPrecision = aLF->lfOutPrecision;
|
|
wLF->lfClipPrecision = aLF->lfClipPrecision;
|
|
wLF->lfQuality = aLF->lfQuality;
|
|
wLF->lfPitchAndFamily = aLF->lfPitchAndFamily;
|
|
|
|
MultiByteToWideChar(uCodePage, 0, aLF->lfFaceName, -1,
|
|
wLF->lfFaceName, LF_FACESIZE);
|
|
|
|
return;
|
|
}
|
|
|
|
#endif // UNICODE
|