/*++ Copyright (c) 1990 Microsoft Corporation Module Name: misc.c Abstract: This file implements the NT console server font routines. Author: Therese Stowell (thereses) 22-Jan-1991 Revision History: --*/ #include "shellprv.h" #pragma hdrstop #include "lnkcon.h" #define CONSOLE_REGISTRY_STRING (TEXT("Console")) #define CONSOLE_REGISTRY_FONTSIZE (TEXT("FontSize")) #define CONSOLE_REGISTRY_FONTFAMILY (TEXT("FontFamily")) #define CONSOLE_REGISTRY_BUFFERSIZE (TEXT("ScreenBufferSize")) #define CONSOLE_REGISTRY_CURSORSIZE (TEXT("CursorSize")) #define CONSOLE_REGISTRY_WINDOWSIZE (TEXT("WindowSize")) #define CONSOLE_REGISTRY_WINDOWPOS (TEXT("WindowPosition")) #define CONSOLE_REGISTRY_FILLATTR (TEXT("ScreenColors")) #define CONSOLE_REGISTRY_POPUPATTR (TEXT("PopupColors")) #define CONSOLE_REGISTRY_FULLSCR (TEXT("FullScreen")) #define CONSOLE_REGISTRY_QUICKEDIT (TEXT("QuickEdit")) #define CONSOLE_REGISTRY_FACENAME (TEXT("FaceName")) #define CONSOLE_REGISTRY_FONTWEIGHT (TEXT("FontWeight")) #define CONSOLE_REGISTRY_INSERTMODE (TEXT("InsertMode")) #define CONSOLE_REGISTRY_HISTORYSIZE (TEXT("HistoryBufferSize")) #define CONSOLE_REGISTRY_HISTORYBUFS (TEXT("NumberOfHistoryBuffers")) #define CONSOLE_REGISTRY_HISTORYNODUP (TEXT("HistoryNoDup")) #define CONSOLE_REGISTRY_COLORTABLE (TEXT("ColorTable%02u")) #define CONSOLE_REGISTRY_CODEPAGE (TEXT("CodePage")) /* * Initial default fonts and face names */ /* * TTPoints -- Initial font pixel heights for TT fonts */ SHORT TTPoints[] = { 5, 6, 7, 8, 10, 12, 14, 16, 18, 20, 24, 28, 36, 72 }; /* * TTPointsDbcs -- Initial font pixel heights for TT fonts of DBCS. */ SHORT TTPointsDbcs[] = { 6, 8, 10, 12, 14, 16, 18, 20, 24, 28, 36, 72 }; typedef struct _FONTENUMDATA { CONSOLEPROP_DATA *pcpd; HDC hDC; BOOL bFindFaces; ULONG ulFE; PSHORT pTTPoints; UINT nTTPoints; UINT uDefCP; } FONTENUMDATA, *PFONTENUMDATA; FACENODE * AddFaceNode(FACENODE * *ppStart, LPTSTR ptsz) { FACENODE * pNew; FACENODE * *ppTmp; int cb; /* * Is it already here? */ for (ppTmp = ppStart; *ppTmp; ppTmp = &((*ppTmp)->pNext)) { if (lstrcmp(((*ppTmp)->atch), ptsz) == 0) { // already there ! return *ppTmp; } } cb = (lstrlen(ptsz) + 1) * sizeof(TCHAR); pNew = (FACENODE *)LocalAlloc(LPTR ,sizeof(FACENODE) + cb); if (pNew == NULL) { return NULL; } pNew->pNext = NULL; pNew->dwFlag = 0; lstrcpy(pNew->atch, ptsz); *ppTmp = pNew; return pNew; } VOID DestroyFaceNodes( CONSOLEPROP_DATA *pcpd ) { FACENODE * pNext; FACENODE * pTmp; pTmp = pcpd->gpFaceNames; while (pTmp != NULL) { pNext = pTmp->pNext; LocalFree(pTmp); pTmp = pNext; } pcpd->gpFaceNames = NULL; } int AddFont( CONSOLEPROP_DATA *pcpd, ENUMLOGFONT *pelf, NEWTEXTMETRIC *pntm, int nFontType, HDC hDC, FACENODE * pFN ) /*++ Add the font desribed by the LOGFONT structure to the font table if it's not already there. --*/ { HFONT hFont; TEXTMETRIC tm; LONG nFont; COORD SizeToShow; COORD SizeActual; COORD SizeWant; BYTE tmFamily; SIZE Size; LPTSTR ptszFace = pelf->elfLogFont.lfFaceName; /* get font info */ SizeWant.Y = (SHORT)pelf->elfLogFont.lfHeight; SizeWant.X = (SHORT)pelf->elfLogFont.lfWidth; CreateBoldFont: hFont = CreateFontIndirect(&pelf->elfLogFont); ASSERT(hFont); if (!hFont) { return FE_SKIPFONT; // same font in other sizes may still be suitable } // // for reasons unbeknownst to me, removing this code causes GDI // to yack, claiming that the font is owned by another process. // SelectObject(hDC, hFont); GetTextMetrics(hDC, &tm); GetTextExtentPoint32(hDC, TEXT("0"), 1, &Size); SizeActual.X = (SHORT)Size.cx; SizeActual.Y = (SHORT)(tm.tmHeight + tm.tmExternalLeading); tmFamily = tm.tmPitchAndFamily; if (TM_IS_TT_FONT(tmFamily) && (SizeWant.Y >= 0)) { SizeToShow = SizeWant; if (SizeWant.X == 0) { // Asking for zero width height gets a default aspect-ratio width // It's better to show that width rather than 0. SizeToShow.X = SizeActual.X; } } else { SizeToShow = SizeActual; } // there's a GDI bug - this assert fails occasionally //ASSERT (tm.tmMaxCharWidth == pntm->tmMaxCharWidth); /* * NOW, determine whether this font entry has already been cached * LATER : it may be possible to do this before creating the font, if * we can trust the dimensions & other info from pntm. * Sort by size: * 1) By pixelheight (negative Y values) * 2) By height (as shown) * 3) By width (as shown) */ for (nFont = 0; nFont < (LONG)pcpd->NumberOfFonts; ++nFont) { COORD SizeShown; if (pcpd->FontInfo[nFont].hFont == NULL) { continue; } if (pcpd->FontInfo[nFont].SizeWant.X > 0) { SizeShown.X = pcpd->FontInfo[nFont].SizeWant.X; } else { SizeShown.X = pcpd->FontInfo[nFont].Size.X; } if (pcpd->FontInfo[nFont].SizeWant.Y > 0) { // This is a font specified by cell height. SizeShown.Y = pcpd->FontInfo[nFont].SizeWant.Y; } else { SizeShown.Y = pcpd->FontInfo[nFont].Size.Y; if (pcpd->FontInfo[nFont].SizeWant.Y < 0) { // This is a TT font specified by character height. if (SizeWant.Y < 0 && SizeWant.Y > pcpd->FontInfo[nFont].SizeWant.Y) { // Requested pixelheight is smaller than this one. break; } } } if (SIZE_EQUAL(SizeShown, SizeToShow) && pcpd->FontInfo[nFont].Family == tmFamily && pcpd->FontInfo[nFont].Weight == tm.tmWeight && lstrcmp(pcpd->FontInfo[nFont].FaceName, ptszFace) == 0) { /* * Already have this font */ DeleteObject(hFont); return FE_FONTOK; } if ((SizeToShow.Y < SizeShown.Y) || (SizeToShow.Y == SizeShown.Y && SizeToShow.X < SizeShown.X)) { /* * This new font is smaller than nFont */ break; } } /* * If we have to grow our font table, do it */ if (pcpd->NumberOfFonts == pcpd->FontInfoLength) { FONT_INFO *Temp; pcpd->FontInfoLength += FONT_INCREMENT; Temp = (FONT_INFO *)LocalReAlloc(pcpd->FontInfo, sizeof(FONT_INFO) * pcpd->FontInfoLength, LMEM_MOVEABLE|LMEM_ZEROINIT); ASSERT(Temp); if (Temp == NULL) { pcpd->FontInfoLength -= FONT_INCREMENT; return FE_ABANDONFONT; // no point enumerating more - no memory! } pcpd->FontInfo = Temp; } /* * The font we are adding should be inserted into the list, * if it is smaller than the last one. */ if (nFont < (LONG)pcpd->NumberOfFonts) { MoveMemory( &pcpd->FontInfo[nFont+1], &pcpd->FontInfo[nFont], sizeof(FONT_INFO) * (pcpd->NumberOfFonts - nFont) ); } /* * Store the font info */ pcpd->FontInfo[nFont].hFont = hFont; pcpd->FontInfo[nFont].Family = tmFamily; pcpd->FontInfo[nFont].Size = SizeActual; if (TM_IS_TT_FONT(tmFamily)) { pcpd->FontInfo[nFont].SizeWant = SizeWant; } else { pcpd->FontInfo[nFont].SizeWant.X = 0; pcpd->FontInfo[nFont].SizeWant.Y = 0; } pcpd->FontInfo[nFont].Weight = tm.tmWeight; pcpd->FontInfo[nFont].FaceName = pFN->atch; pcpd->FontInfo[nFont].tmCharSet = tm.tmCharSet; ++pcpd->NumberOfFonts; /* * If this is a true type font, create a bold version too. */ if (nFontType == TRUETYPE_FONTTYPE && !IS_BOLD(pcpd->FontInfo[nFont].Weight)) { pelf->elfLogFont.lfWeight = FW_BOLD; goto CreateBoldFont; } return FE_FONTOK; // and continue enumeration } NTSTATUS InitializeFonts( CONSOLEPROP_DATA *pcpd ) { return EnumerateFonts( pcpd, EF_DEFFACE); // Just the Default font } STDAPI_(void) DestroyFonts( CONSOLEPROP_DATA *pcpd ) { ULONG FontIndex; if (pcpd->FontInfo != NULL) { for (FontIndex = 0; FontIndex < pcpd->NumberOfFonts; FontIndex++) { DeleteObject(pcpd->FontInfo[FontIndex].hFont); } LocalFree(pcpd->FontInfo); pcpd->FontInfo = NULL; pcpd->NumberOfFonts = 0; } DestroyFaceNodes( pcpd ); } /* * Returns bit combination * FE_ABANDONFONT - do not continue enumerating this font * FE_SKIPFONT - skip this font but keep enumerating * FE_FONTOK - font was created and added to cache or already there */ int FontEnum( ENUMLOGFONT *pelf, NEWTEXTMETRIC *pntm, int nFontType, PFONTENUMDATA pfed ) /*++ Is called exactly once by GDI for each font in the system. This routine is used to store the FONT_INFO structure. --*/ { UINT i; LPTSTR ptszFace = pelf->elfLogFont.lfFaceName; FACENODE * pFN; BOOL bNegAC; #ifdef DEBUG OSVERSIONINFO osvi; osvi.dwOSVersionInfoSize = sizeof(osvi); GetVersionEx(&osvi); // NTMW_STRUCTURE is different on 5.0+ platforms and the flag for 5.0+ // platforms now lives in NEWTEXTMETRIC structure. AssertMsg(osvi.dwMajorVersion > 4, TEXT("We now only support running on Win2k or Millennium and later so we should never hit this.")); #endif bNegAC = !(pntm->ntmFlags & NTM_NONNEGATIVE_AC); // // reject variable width and italic fonts, also tt fonts with neg ac // if ( !(pelf->elfLogFont.lfPitchAndFamily & FIXED_PITCH) || (pelf->elfLogFont.lfItalic) || bNegAC ) { if (!IsAvailableTTFont(pfed->pcpd,ptszFace)) return pfed->bFindFaces ? FE_SKIPFONT : FE_ABANDONFONT; } /* * reject TT fonts for whoom family is not modern, that is do not use * FF_DONTCARE // may be surprised unpleasantly * FF_DECORATIVE // likely to be symbol fonts * FF_SCRIPT // cursive, inappropriate for console * FF_SWISS OR FF_ROMAN // variable pitch */ if ((nFontType == TRUETYPE_FONTTYPE) && ((pelf->elfLogFont.lfPitchAndFamily & 0xf0) != FF_MODERN)) { return pfed->bFindFaces ? FE_SKIPFONT : FE_ABANDONFONT; } /* * reject non-TT fonts that aren't OEM */ if ((nFontType != TRUETYPE_FONTTYPE) && (!IsFarEastCP(pfed->uDefCP) || !IS_ANY_DBCS_CHARSET(pelf->elfLogFont.lfCharSet)) && (pelf->elfLogFont.lfCharSet != OEM_CHARSET)) { return pfed->bFindFaces ? FE_SKIPFONT : FE_ABANDONFONT; } /* * reject non-TT vertical/non-Terminal Font for FE */ if (IsFarEastCP(pfed->uDefCP)) { if ((nFontType != TRUETYPE_FONTTYPE) && ((ptszFace[0] == TEXT('@')) || (lstrcmp(ptszFace, TEXT("Terminal")) != 0))) { return pfed->bFindFaces ? FE_SKIPFONT : FE_ABANDONFONT; } } /* * reject Far East TT fonts that aren't Far East charset. */ if (IsAvailableTTFont(pfed->pcpd, ptszFace) && !IS_ANY_DBCS_CHARSET(pelf->elfLogFont.lfCharSet) && !IsAvailableTTFontCP(pfed->pcpd, ptszFace,0) ) { return FE_SKIPFONT; // should be enumerate next charset. } /* * Add or find the facename */ pFN = AddFaceNode(&pfed->pcpd->gpFaceNames, ptszFace); if (pFN == NULL) { return FE_ABANDONFONT; } if (pfed->bFindFaces) { DWORD dwFontType = 0; if (nFontType == TRUETYPE_FONTTYPE) { dwFontType = EF_TTFONT; } else if (nFontType == RASTER_FONTTYPE) { dwFontType = EF_OEMFONT; } pFN->dwFlag |= dwFontType | EF_NEW; if (IS_ANY_DBCS_CHARSET(pelf->elfLogFont.lfCharSet)) pFN->dwFlag |= EF_DBCSFONT; return FE_SKIPFONT; } if (IS_BOLD(pelf->elfLogFont.lfWeight)) { // return FE_SKIPFONT; } /* * Add the font to the table. If this is a true type font, add the * sizes from the array. Otherwise, just add the size we got. */ if (nFontType & TRUETYPE_FONTTYPE) { for (i = 0; i < pfed->nTTPoints; i++) { pelf->elfLogFont.lfHeight = pfed->pTTPoints[i]; pelf->elfLogFont.lfWidth = 0; pelf->elfLogFont.lfWeight = 400; pfed->ulFE |= AddFont(pfed->pcpd, pelf, pntm, nFontType, pfed->hDC, pFN); if (pfed->ulFE & FE_ABANDONFONT) { return FE_ABANDONFONT; } } } else { pfed->ulFE |= AddFont(pfed->pcpd, pelf, pntm, nFontType, pfed->hDC, pFN); if (pfed->ulFE & FE_ABANDONFONT) { return FE_ABANDONFONT; } } return FE_FONTOK; // and continue enumeration } BOOL DoFontEnum( CONSOLEPROP_DATA *pcpd, HDC hDC, LPTSTR ptszFace, PSHORT pTTPoints, UINT nTTPoints) { BOOL bDeleteDC = FALSE; FONTENUMDATA fed; LOGFONT LogFont; if (hDC == NULL) { hDC = CreateDC(TEXT("DISPLAY"), NULL, NULL, NULL); bDeleteDC = TRUE; } fed.pcpd = pcpd; fed.hDC = hDC; fed.bFindFaces = (ptszFace == NULL); fed.ulFE = 0; fed.pTTPoints = pTTPoints; fed.nTTPoints = nTTPoints; fed.uDefCP = pcpd->uOEMCP; RtlZeroMemory(&LogFont, sizeof(LOGFONT)); LogFont.lfCharSet = DEFAULT_CHARSET; if (ptszFace) _tcscpy(LogFont.lfFaceName, ptszFace); /* * EnumFontFamiliesEx function enumerates one font in every face in every character set. */ EnumFontFamiliesEx(hDC, &LogFont, (FONTENUMPROC)FontEnum, (LPARAM)&fed, 0); if (bDeleteDC) { DeleteDC(hDC); } return (fed.ulFE & FE_FONTOK) != 0; } VOID RemoveFace(CONSOLEPROP_DATA *pcpd, LPTSTR ptszFace) { DWORD i; int nToRemove = 0; // // Delete & Remove fonts with Face Name == ptszFace // for (i = 0; i < pcpd->NumberOfFonts; i++) { if (lstrcmp(pcpd->FontInfo[i].FaceName, ptszFace) == 0) { BOOL bDeleted = DeleteObject(pcpd->FontInfo[i].hFont); pcpd->FontInfo[i].hFont = NULL; nToRemove++; } else if (nToRemove > 0) { /* * Shuffle from FontInfo[i] down nToRemove slots. */ MoveMemory( &pcpd->FontInfo[i - nToRemove], &pcpd->FontInfo[i], sizeof(FONT_INFO)*(pcpd->NumberOfFonts - i) ); pcpd->NumberOfFonts -= nToRemove; i -= nToRemove; nToRemove = 0; } } pcpd->NumberOfFonts -= nToRemove; } NTSTATUS EnumerateFonts( CONSOLEPROP_DATA *pcpd, DWORD Flags) { TEXTMETRIC tm; HDC hDC; FACENODE * pFN; ULONG ulOldEnumFilter; BOOL bEnumOEMFace = TRUE; DWORD FontIndex; DWORD dwFontType = 0; dwFontType = (EF_TTFONT|EF_OEMFONT|EF_DEFFACE) & Flags; if (pcpd->FontInfo == NULL) { // // allocate memory for the font array // pcpd->NumberOfFonts = 0; pcpd->FontInfo = (FONT_INFO *)LocalAlloc(LPTR, sizeof(FONT_INFO) * INITIAL_FONTS); if (pcpd->FontInfo == NULL) return STATUS_NO_MEMORY; pcpd->FontInfoLength = INITIAL_FONTS; } hDC = CreateDC(TEXT("DISPLAY"), NULL, NULL, NULL); // Before enumeration, turn off font enumeration filters. ulOldEnumFilter = SetFontEnumeration(FE_FILTER_NONE); if (Flags & EF_DEFFACE) { SelectObject(hDC, GetStockObject(OEM_FIXED_FONT)); GetTextFace(hDC, LF_FACESIZE, pcpd->DefaultFaceName); // Make sure we are going to enumerate the OEM face. pFN = AddFaceNode(&pcpd->gpFaceNames, pcpd->DefaultFaceName); if (NULL == pFN) { LocalFree(pcpd->FontInfo); pcpd->FontInfo = NULL; pcpd->FontInfoLength = 0; pcpd->NumberOfFonts = 0; SetFontEnumeration(ulOldEnumFilter); DeleteDC(hDC); return STATUS_NO_MEMORY; } pFN->dwFlag |= EF_DEFFACE | EF_OEMFONT; GetTextMetrics(hDC, &tm); pcpd->DefaultFontSize.X = (SHORT)(tm.tmMaxCharWidth); pcpd->DefaultFontSize.Y = (SHORT)(tm.tmHeight+tm.tmExternalLeading); pcpd->DefaultFontFamily = tm.tmPitchAndFamily; if (IS_ANY_DBCS_CHARSET(tm.tmCharSet)) pcpd->DefaultFontSize.X /= 2; } if (pcpd->gbEnumerateFaces) { /* * Set the EF_OLD bit and clear the EF_NEW bit * for all previously available faces */ for (pFN = pcpd->gpFaceNames; pFN; pFN = pFN->pNext) { pFN->dwFlag |= EF_OLD; pFN->dwFlag &= ~EF_NEW; } // // Use DoFontEnum to get the names of all the suitable Faces // All facenames found will be put in gpFaceNames with // the EF_NEW bit set. // DoFontEnum(pcpd, hDC, NULL, TTPoints, 1); pcpd->gbEnumerateFaces = FALSE; } // Use DoFontEnum to get all fonts from the system. Our FontEnum // proc puts just the ones we want into an array // for (pFN = pcpd->gpFaceNames; pFN; pFN = pFN->pNext) { if ((pFN->dwFlag & (EF_OLD|EF_NEW)) == EF_OLD) { // The face is no longer available RemoveFace(pcpd, pFN->atch); pFN->dwFlag &= ~EF_ENUMERATED; continue; } if ((pFN->dwFlag & dwFontType) == 0) { // not the kind of face we want continue; } if (pFN->dwFlag & EF_ENUMERATED) { // we already enumerated this face continue; } if (pFN->dwFlag & EF_TTFONT) { if (IsFarEastCP(pcpd->uOEMCP) && !IsAvailableTTFontCP(pcpd, pFN->atch, 0)) DoFontEnum(pcpd, hDC, pFN->atch, TTPointsDbcs, NELEM(TTPointsDbcs)); else DoFontEnum(pcpd, hDC, pFN->atch, TTPoints, NELEM(TTPoints)); } else { DoFontEnum(pcpd, hDC, pFN->atch, NULL, 0); // If we find that the face just enumerated is the same as OEM, // reset flag so we don't try to enumerate it again. if (lstrcmpi(pFN->atch, pcpd->DefaultFaceName) == 0) { bEnumOEMFace = FALSE; } } pFN->dwFlag |= EF_ENUMERATED; } // After enumerating fonts, restore the font enumeration filter. SetFontEnumeration(ulOldEnumFilter); DeleteDC(hDC); for (FontIndex = 0; FontIndex < pcpd->NumberOfFonts; FontIndex++) { if (pcpd->FontInfo[FontIndex].Size.X == pcpd->DefaultFontSize.X && pcpd->FontInfo[FontIndex].Size.Y == pcpd->DefaultFontSize.Y && pcpd->FontInfo[FontIndex].Family == pcpd->DefaultFontFamily) { break; } } ASSERT(FontIndex < pcpd->NumberOfFonts); if (FontIndex < pcpd->NumberOfFonts) { pcpd->DefaultFontIndex = FontIndex; } else { pcpd->DefaultFontIndex = 0; } return STATUS_SUCCESS; } NTSTATUS GetNumFonts( CONSOLEPROP_DATA *pcpd, OUT PULONG NumFonts ) { *NumFonts = pcpd->NumberOfFonts; return STATUS_SUCCESS; } NTSTATUS GetFontSize( CONSOLEPROP_DATA *pcpd, IN DWORD FontIndex, OUT PCOORD FontSize ) { if (FontIndex >= pcpd->NumberOfFonts) return STATUS_INVALID_PARAMETER; *FontSize = pcpd->FontInfo[FontIndex].Size; return STATUS_SUCCESS; } /* * Get the font index for a new font * If necessary, attempt to create the font. * Always return a valid FontIndex (even if not correct) * Family: Find/Create a font with of this Family * 0 - don't care * ptszFace: Find/Create a font with this face name. * NULL or TEXT("") - use DefaultFaceName * Size: Must match SizeWant or actual Size. */ int FindCreateFont( CONSOLEPROP_DATA *pcpd, DWORD Family, LPTSTR ptszFace, COORD Size, LONG Weight) { #define NOT_CREATED_NOR_FOUND -1 #define CREATED_BUT_NOT_FOUND -2 int i; int FontIndex = NOT_CREATED_NOR_FOUND; BOOL bFontOK; TCHAR AltFaceName[LF_FACESIZE]; COORD AltFontSize; BYTE AltFontFamily; ULONG AltFontIndex = 0; LPTSTR ptszAltFace = NULL; UINT uCurrentCP = pcpd->lpFEConsole->uCodePage; UINT uDefaultCP = pcpd->uOEMCP; BYTE CharSet = CodePageToCharSet(uCurrentCP); if (!IsFarEastCP(uDefaultCP) || IS_ANY_DBCS_CHARSET(CharSet)) { if (ptszFace == NULL || *ptszFace == TEXT('\0')) { ptszFace = pcpd->DefaultFaceName; } if (Size.Y == 0) { Size = pcpd->DefaultFontSize; } } else { MakeAltRasterFont(pcpd, uCurrentCP, &AltFontSize, &AltFontFamily, &AltFontIndex, AltFaceName); if (ptszFace == NULL || *ptszFace == L'\0') { ptszFace = AltFaceName; } if (Size.Y == 0) { Size.X = AltFontSize.X; Size.Y = AltFontSize.Y; } } if (IsAvailableTTFont(pcpd, ptszFace)) { ptszAltFace = GetAltFaceName(pcpd, ptszFace); } else { ptszAltFace = ptszFace; } /* * Try to find the exact font */ TryFindExactFont: for (i=0; i < (int)pcpd->NumberOfFonts; i++) { /* * If looking for a particular Family, skip non-matches */ if ((Family != 0) && ((BYTE)Family != pcpd->FontInfo[i].Family)) { continue; } /* * Skip non-matching sizes */ if ((!SIZE_EQUAL(pcpd->FontInfo[i].SizeWant, Size) && !SIZE_EQUAL(pcpd->FontInfo[i].Size, Size))) { continue; } /* * Skip non-matching weights */ if ((Weight != 0) && (Weight != pcpd->FontInfo[i].Weight)) { continue; } /* * Skip fonts that have unmatched charset */ if (!TM_IS_TT_FONT(pcpd->FontInfo[i].Family) && pcpd->FontInfo[i].tmCharSet != CharSet) { continue; } /* * Size (and maybe Family) match. * If we don't care about the name, or if it matches, use this font. * Else if name doesn't match and it is a raster font, consider it. */ if ((ptszFace == NULL) || (ptszFace[0] == TEXT('\0')) || (lstrcmp(pcpd->FontInfo[i].FaceName, ptszFace) == 0) || (lstrcmp(pcpd->FontInfo[i].FaceName, ptszAltFace) == 0) ) { FontIndex = i; goto FoundFont; } else if (!TM_IS_TT_FONT(pcpd->FontInfo[i].Family)) { FontIndex = i; } } if (FontIndex == NOT_CREATED_NOR_FOUND) { /* * Didn't find the exact font, so try to create it */ ULONG ulOldEnumFilter; ulOldEnumFilter = SetFontEnumeration(FE_FILTER_NONE); if (Size.Y < 0) { Size.Y = -Size.Y; } bFontOK = DoFontEnum(pcpd, NULL, ptszFace, &Size.Y, 1); SetFontEnumeration(ulOldEnumFilter); if (bFontOK) { FontIndex = CREATED_BUT_NOT_FOUND; goto TryFindExactFont; } else { } } else if (FontIndex >= 0) { // a close Raster Font fit - only the name doesn't match. goto FoundFont; } /* * Failed to find exact match, even after enumeration, so now try * to find a font of same family and same size or bigger */ for (i=0; i < (int)pcpd->NumberOfFonts; i++) { if ((Family != 0) && ((BYTE)Family != pcpd->FontInfo[i].Family)) { continue; } if (!TM_IS_TT_FONT(pcpd->FontInfo[i].Family) && pcpd->FontInfo[i].tmCharSet != CharSet) { continue; } if (pcpd->FontInfo[i].Size.Y >= Size.Y && pcpd->FontInfo[i].Size.X >= Size.X) { // Same family, size >= desired. FontIndex = i; break; } } if (FontIndex < 0) { if (uCurrentCP == uDefaultCP) { FontIndex = pcpd->DefaultFontIndex; } else { FontIndex = AltFontIndex; } } FoundFont: return FontIndex; #undef NOT_CREATED_NOR_FOUND #undef CREATED_BUT_NOT_FOUND } LPTSTR TranslateConsoleTitle( LPTSTR ConsoleTitle ) /*++ this routine translates path characters into '_' characters because the NT registry apis do not allow the creation of keys with names that contain path characters. it allocates a buffer that must be freed. --*/ { int ConsoleTitleLength, i; LPTSTR TranslatedTitle; ConsoleTitleLength = lstrlen(ConsoleTitle) + 1; TranslatedTitle = LocalAlloc(LPTR, ConsoleTitleLength * sizeof(TCHAR)); if (TranslatedTitle == NULL) { return NULL; } for (i = 0; i < ConsoleTitleLength; i++) { if (ConsoleTitle[i] == TEXT('\\')) { TranslatedTitle[i] = TEXT('_'); } else { TranslatedTitle[i] = ConsoleTitle[i]; } } return TranslatedTitle; } void InitRegistryValues( CONSOLEPROP_DATA *pcpd ) /*++ Routine Description: This routine allocates a state info structure and fill it in with default values. It then tries to load the default settings for console from the registry. Arguments: none Return Value: pStateInfo - pointer to structure to receive information --*/ { TCHAR chSave; pcpd->lpConsole->wFillAttribute = 0x07; // white on black pcpd->lpConsole->wPopupFillAttribute = 0xf5; // purple on white pcpd->lpConsole->bInsertMode = FALSE; pcpd->lpConsole->bQuickEdit = FALSE; pcpd->lpConsole->bFullScreen = FALSE; pcpd->lpConsole->dwScreenBufferSize.X = 80; pcpd->lpConsole->dwScreenBufferSize.Y = 25; pcpd->lpConsole->dwWindowSize.X = 80; pcpd->lpConsole->dwWindowSize.Y = 25; pcpd->lpConsole->dwWindowOrigin.X = 0; pcpd->lpConsole->dwWindowOrigin.Y = 0; pcpd->lpConsole->bAutoPosition = TRUE; pcpd->lpConsole->dwFontSize.X = 0; pcpd->lpConsole->dwFontSize.Y = 0; pcpd->lpConsole->uFontFamily = 0; pcpd->lpConsole->uFontWeight = 0; #ifdef UNICODE FillMemory( pcpd->lpConsole->FaceName, sizeof(pcpd->lpConsole->FaceName), 0 ); pcpd->lpFaceName = (LPTSTR)pcpd->lpConsole->FaceName; #else FillMemory( pcpd->szFaceName, sizeof(pcpd->szFaceName), 0 ); pcpd->lpFaceName = pcpd->szFaceName; #endif pcpd->lpConsole->uCursorSize = 25; pcpd->lpConsole->uHistoryBufferSize = 25; pcpd->lpConsole->uNumberOfHistoryBuffers = 4; pcpd->lpConsole->bHistoryNoDup = 0; pcpd->lpConsole->ColorTable[ 0] = RGB(0, 0, 0 ); pcpd->lpConsole->ColorTable[ 1] = RGB(0, 0, 0x80); pcpd->lpConsole->ColorTable[ 2] = RGB(0, 0x80,0 ); pcpd->lpConsole->ColorTable[ 3] = RGB(0, 0x80,0x80); pcpd->lpConsole->ColorTable[ 4] = RGB(0x80,0, 0 ); pcpd->lpConsole->ColorTable[ 5] = RGB(0x80,0, 0x80); pcpd->lpConsole->ColorTable[ 6] = RGB(0x80,0x80,0 ); pcpd->lpConsole->ColorTable[ 7] = RGB(0xC0,0xC0,0xC0); pcpd->lpConsole->ColorTable[ 8] = RGB(0x80,0x80,0x80); pcpd->lpConsole->ColorTable[ 9] = RGB(0, 0, 0xFF); pcpd->lpConsole->ColorTable[10] = RGB(0, 0xFF,0 ); pcpd->lpConsole->ColorTable[11] = RGB(0, 0xFF,0xFF); pcpd->lpConsole->ColorTable[12] = RGB(0xFF,0, 0 ); pcpd->lpConsole->ColorTable[13] = RGB(0xFF,0, 0xFF); pcpd->lpConsole->ColorTable[14] = RGB(0xFF,0xFF,0 ); pcpd->lpConsole->ColorTable[15] = RGB(0xFF,0xFF,0xFF); pcpd->lpFEConsole->uCodePage = pcpd->uOEMCP; // make console title NULL so we load the default settings for the console chSave = pcpd->ConsoleTitle[0]; pcpd->ConsoleTitle[0] = TEXT('\0'); GetRegistryValues( pcpd ); // restore the console title pcpd->ConsoleTitle[0] = chSave; } VOID GetTitleFromLinkName( LPTSTR szLinkName, LPTSTR szTitle ) { DWORD dwLen; LPTSTR pLnk, pDot; LPTSTR pPath = szLinkName; // Error checking if (!szTitle) return; if (!szLinkName) { szTitle[0] = TEXT('\0'); return; } // find filename at end of fully qualified link name and point pLnk to it for (pLnk = pPath; *pPath; pPath++) { if ( (pPath[0] == TEXT('\\') || pPath[0] == TEXT(':')) && pPath[1] && (pPath[1] != TEXT('\\')) ) pLnk = pPath + 1; } // find extension (.lnk) pPath = pLnk; for (pDot = NULL; *pPath; pPath++) { switch (*pPath) { case TEXT('.'): pDot = pPath; // remember the last dot break; case TEXT('\\'): case TEXT(' '): // extensions can't have spaces pDot = NULL; // forget last dot, it was in a directory break; } } // if we found the extension, pDot points to it, if not, pDot // is NULL. if (pDot) { dwLen = min( (DWORD) (pDot - pLnk), (MAX_TITLE_LEN-1) ); } else { dwLen = min( lstrlen(pLnk), (MAX_TITLE_LEN-1) ); } CopyMemory(szTitle, pLnk, dwLen*sizeof(TCHAR)); szTitle[ dwLen ] = TEXT('\0'); } VOID GetRegistryValues( CONSOLEPROP_DATA *pcpd ) /*++ Routine Description: This routine reads in values from the registry and places them in the supplied structure. Arguments: pStateInfo - optional pointer to structure to receive information Return Value: current page number --*/ { HKEY hCurrentUserKey; HKEY hConsoleKey; HKEY hTitleKey; LPTSTR TranslatedTitle; DWORD dwValue, dwSize; DWORD dwRet = 0; DWORD i; WCHAR awchBuffer[LF_FACESIZE]; // // Open the current user registry key // if (RegOpenKey( HKEY_CURRENT_USER, NULL, &hCurrentUserKey)!=ERROR_SUCCESS) return; // // Open the console registry key // if (RegOpenKey(hCurrentUserKey,CONSOLE_REGISTRY_STRING,&hConsoleKey)!=ERROR_SUCCESS) { RegCloseKey(hCurrentUserKey); return; } // // If there is no structure to fill out, just bail out // if ((!pcpd) || (!pcpd->lpConsole)) goto CloseKeys; // // Open the console title subkey, if there is one // if (pcpd->ConsoleTitle[0] != TEXT('\0')) { TranslatedTitle = TranslateConsoleTitle(pcpd->ConsoleTitle); if (TranslatedTitle == NULL) goto GetDefaultConsole; dwValue = RegOpenKey( hConsoleKey, TranslatedTitle, &hTitleKey); LocalFree(TranslatedTitle); if (dwValue!=ERROR_SUCCESS) goto GetDefaultConsole; } else { GetDefaultConsole: hTitleKey = hConsoleKey; } // // Initial screen fill // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_FILLATTR, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->wFillAttribute = (WORD)dwValue; } // // Initial popup fill // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_POPUPATTR, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->wPopupFillAttribute = (WORD)dwValue; } // // Initial color table // for (i = 0; i < 16; i++) { wsprintf((LPTSTR)awchBuffer, CONSOLE_REGISTRY_COLORTABLE, i); dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, (LPTSTR)awchBuffer, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->ColorTable[i] = dwValue; } } // // Initial insert mode // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_INSERTMODE, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->bInsertMode = !!dwValue; } // // Initial quick edit mode // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_QUICKEDIT, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->bQuickEdit = !!dwValue; } #ifdef i386 // // Initial full screen mode // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_FULLSCR, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->bFullScreen = !!dwValue; } #endif // // Initial code page // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_CODEPAGE, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpFEConsole->uCodePage = (UINT)dwValue; } // // Initial screen buffer size // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_BUFFERSIZE, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->dwScreenBufferSize.X = LOWORD(dwValue); pcpd->lpConsole->dwScreenBufferSize.Y = HIWORD(dwValue); } // // Initial window size // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_WINDOWSIZE, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->dwWindowSize.X = LOWORD(dwValue); pcpd->lpConsole->dwWindowSize.Y = HIWORD(dwValue); } // // Initial window position // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_WINDOWPOS, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->dwWindowOrigin.X = (SHORT)LOWORD(dwValue); pcpd->lpConsole->dwWindowOrigin.Y = (SHORT)HIWORD(dwValue); pcpd->lpConsole->bAutoPosition = FALSE; } // // Initial font size // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_FONTSIZE, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->dwFontSize.X = LOWORD(dwValue); pcpd->lpConsole->dwFontSize.Y = HIWORD(dwValue); } // // Initial font family // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_FONTFAMILY, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->uFontFamily = dwValue; } // // Initial font weight // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_FONTWEIGHT, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->uFontWeight = dwValue; } // // Initial font face name // dwSize = sizeof(awchBuffer); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_FACENAME, NULL, NULL, (LPBYTE)awchBuffer, &dwSize ) == ERROR_SUCCESS) { CopyMemory((LPBYTE)pcpd->lpFaceName, (LPBYTE)awchBuffer, LF_FACESIZE*sizeof(TCHAR)); } // // Initial cursor size // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_CURSORSIZE, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->uCursorSize = dwValue; } // // Initial history buffer size // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_HISTORYSIZE, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->uHistoryBufferSize = dwValue; } // // Initial number of history buffers // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_HISTORYBUFS, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->uNumberOfHistoryBuffers = dwValue; } // // Initial history duplication mode // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_HISTORYNODUP, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpConsole->bHistoryNoDup = dwValue; } // // Close the registry keys // if (hTitleKey != hConsoleKey) { RegCloseKey(hTitleKey); } CloseKeys: RegCloseKey(hConsoleKey); RegCloseKey(hCurrentUserKey); } VOID SetRegistryValues( CONSOLEPROP_DATA *pcpd ) /*++ Routine Description: This routine writes values to the registry from the supplied structure. Arguments: pStateInfo - optional pointer to structure containing information dwPage - current page number Return Value: none --*/ { HKEY hCurrentUserKey; HKEY hConsoleKey; HKEY hTitleKey; LPTSTR TranslatedTitle; DWORD dwValue; DWORD i; WCHAR awchBuffer[LF_FACESIZE]; // // Open the current user registry key // if (RegOpenKey( HKEY_CURRENT_USER, NULL, &hCurrentUserKey )!=ERROR_SUCCESS) { return; } // // Open the console registry key // if (RegCreateKey( hCurrentUserKey, CONSOLE_REGISTRY_STRING, &hConsoleKey )!=ERROR_SUCCESS) { RegCloseKey(hCurrentUserKey); return; } // // If we only want to save the current page, bail out // if (pcpd == NULL) { goto CloseKeys; } // // Open the console title subkey, if there is one // if (pcpd->ConsoleTitle[0] != TEXT('\0')) { TranslatedTitle = TranslateConsoleTitle(pcpd->ConsoleTitle); if (TranslatedTitle == NULL) { RegCloseKey(hConsoleKey); RegCloseKey(hCurrentUserKey); return; } dwValue = RegCreateKey( hConsoleKey, TranslatedTitle, &hTitleKey); LocalFree(TranslatedTitle); if (dwValue!=ERROR_SUCCESS) { RegCloseKey(hConsoleKey); RegCloseKey(hCurrentUserKey); return; } } else { hTitleKey = hConsoleKey; } // // Save screen and popup colors and color table // dwValue = pcpd->lpConsole->wFillAttribute; RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_FILLATTR, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); dwValue = pcpd->lpConsole->wPopupFillAttribute; RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_POPUPATTR, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); for (i = 0; i < 16; i++) { dwValue = pcpd->lpConsole->ColorTable[i]; wsprintf((LPTSTR)awchBuffer, CONSOLE_REGISTRY_COLORTABLE, i); RegSetValueEx( hTitleKey, (LPTSTR)awchBuffer, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); } // // Save insert, quickedit, and fullscreen mode settings // dwValue = pcpd->lpConsole->bInsertMode; RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_INSERTMODE, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); dwValue = pcpd->lpConsole->bQuickEdit; RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_QUICKEDIT, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); #ifdef i386 dwValue = pcpd->lpConsole->bFullScreen; RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_FULLSCR, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); #endif // // Save screen buffer size // dwValue = MAKELONG(pcpd->lpConsole->dwScreenBufferSize.X, pcpd->lpConsole->dwScreenBufferSize.Y); RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_BUFFERSIZE, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); // // Save window size // dwValue = MAKELONG(pcpd->lpConsole->dwWindowSize.X, pcpd->lpConsole->dwWindowSize.Y); RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_WINDOWSIZE, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); // // Save window position // if (pcpd->lpConsole->bAutoPosition) { RegDeleteKey(hTitleKey, CONSOLE_REGISTRY_WINDOWPOS); } else { dwValue = MAKELONG(pcpd->lpConsole->dwWindowOrigin.X, pcpd->lpConsole->dwWindowOrigin.Y); RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_WINDOWPOS, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); } // // Save font size, family, weight, and face name // dwValue = MAKELONG(pcpd->lpConsole->dwFontSize.X, pcpd->lpConsole->dwFontSize.Y); RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_FONTSIZE, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); dwValue = pcpd->lpConsole->uFontFamily; RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_FONTFAMILY, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); dwValue = pcpd->lpConsole->uFontWeight; RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_FONTWEIGHT, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_FACENAME, 0, REG_SZ, (LPBYTE)pcpd->lpFaceName, (lstrlen(pcpd->lpFaceName) + 1) * sizeof(TCHAR) ); // // Save cursor size // dwValue = pcpd->lpConsole->uCursorSize; RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_CURSORSIZE, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); // // Save history buffer size and number // dwValue = pcpd->lpConsole->uHistoryBufferSize; RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_HISTORYSIZE, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); dwValue = pcpd->lpConsole->uNumberOfHistoryBuffers; RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_HISTORYBUFS, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); dwValue = pcpd->lpConsole->bHistoryNoDup; RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_HISTORYNODUP, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); // // Close the registry keys // if (hTitleKey != hConsoleKey) { RegCloseKey(hTitleKey); } CloseKeys: RegCloseKey(hConsoleKey); RegCloseKey(hCurrentUserKey); } void InitFERegistryValues( CONSOLEPROP_DATA *pcpd ) /*++ Routine Description: This routine allocates a state info structure and fill it in with default values. It then tries to load the default settings for console from the registry. Arguments: none Return Value: pStateInfo - pointer to structure to receive information --*/ { /* * In this case: console reads a property of US version. * It doesn't have code page information. * Console should sets some code page as default. * However, I don't know right value. 437 is temporary value. */ pcpd->lpFEConsole->uCodePage = 437; GetFERegistryValues( pcpd ); } VOID GetFERegistryValues( CONSOLEPROP_DATA *pcpd ) /*++ Routine Description: This routine reads in values from the registry and places them in the supplied structure. Arguments: pStateInfo - optional pointer to structure to receive information Return Value: current page number --*/ { HKEY hCurrentUserKey; HKEY hConsoleKey; HKEY hTitleKey; LPTSTR TranslatedTitle; DWORD dwValue, dwSize; DWORD dwRet = 0; // // Open the current user registry key // if (RegOpenKey( HKEY_CURRENT_USER, NULL, &hCurrentUserKey)!=ERROR_SUCCESS) return; // // Open the console registry key // if (RegOpenKey(hCurrentUserKey,CONSOLE_REGISTRY_STRING,&hConsoleKey)!=ERROR_SUCCESS) { NtClose(hCurrentUserKey); return; } // // If there is no structure to fill out, just bail out // if ((!pcpd) || (!pcpd->lpFEConsole)) goto CloseKeys; // // Open the console title subkey, if there is one // if (pcpd->ConsoleTitle[0] != TEXT('\0')) { TranslatedTitle = TranslateConsoleTitle(pcpd->ConsoleTitle); if (TranslatedTitle == NULL) goto CloseKeys; dwValue = RegOpenKey( hConsoleKey, TranslatedTitle, &hTitleKey); LocalFree(TranslatedTitle); if (dwValue!=ERROR_SUCCESS) goto CloseKeys; } else { goto CloseKeys; } // // Initial code page // dwSize = sizeof(dwValue); if (SHQueryValueEx( hTitleKey, CONSOLE_REGISTRY_CODEPAGE, NULL, NULL, (LPBYTE)&dwValue, &dwSize ) == ERROR_SUCCESS) { pcpd->lpFEConsole->uCodePage = (UINT)dwValue; } // // Close the registry keys // if (hTitleKey != hConsoleKey) { RegCloseKey(hTitleKey); } CloseKeys: RegCloseKey(hConsoleKey); RegCloseKey(hCurrentUserKey); } VOID SetFERegistryValues( CONSOLEPROP_DATA *pcpd ) /*++ Routine Description: This routine writes values to the registry from the supplied structure. Arguments: pStateInfo - optional pointer to structure containing information dwPage - current page number Return Value: none --*/ { HKEY hCurrentUserKey; HKEY hConsoleKey; HKEY hTitleKey; LPTSTR TranslatedTitle; DWORD dwValue; // // Open the current user registry key // if (RegOpenKey( HKEY_CURRENT_USER, NULL, &hCurrentUserKey )!=ERROR_SUCCESS) { return; } // // Open the console registry key // if (RegCreateKey( hCurrentUserKey, CONSOLE_REGISTRY_STRING, &hConsoleKey )!=ERROR_SUCCESS) { RegCloseKey(hCurrentUserKey); return; } // // If we only want to save the current page, bail out // if (pcpd == NULL) { goto CloseKeys; } // // Open the console title subkey, if there is one // if (pcpd->ConsoleTitle[0] != TEXT('\0')) { TranslatedTitle = TranslateConsoleTitle(pcpd->ConsoleTitle); if (TranslatedTitle == NULL) { RegCloseKey(hConsoleKey); RegCloseKey(hCurrentUserKey); return; } dwValue = RegCreateKey( hConsoleKey, TranslatedTitle, &hTitleKey); LocalFree(TranslatedTitle); if (dwValue!=ERROR_SUCCESS) { RegCloseKey(hConsoleKey); RegCloseKey(hCurrentUserKey); return; } } else { hTitleKey = hConsoleKey; } // scotthsu dwValue = pcpd->lpFEConsole->uCodePage; RegSetValueEx( hTitleKey, CONSOLE_REGISTRY_CODEPAGE, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue) ); // // Close the registry keys // if (hTitleKey != hConsoleKey) { RegCloseKey(hTitleKey); } CloseKeys: RegCloseKey(hConsoleKey); RegCloseKey(hCurrentUserKey); }