|
|
#include "precomp.h"
//
// FH.CPP
// Font Handling
//
// Copyright(c) Microsoft 1997-
//
#define MLZ_FILE_ZONE ZONE_CORE
//
// FH_Init()
//
// This routine allocates a structure for the local font list, then fills
// it in. It returns the number of local fonts in the list, or zero if
// something went wrong
//
UINT FH_Init(void){ UINT cFonts = 0;
DebugEntry(FH_Init);
//
// Create the font array and the font index array
//
g_fhFonts = new FHLOCALFONTS; if (!g_fhFonts) { ERROR_OUT(("FH_Init: couldn't allocate g_fhFonts local list")); DC_QUIT; }
ZeroMemory(g_fhFonts, sizeof(FHLOCALFONTS)); SET_STAMP(g_fhFonts, FHLOCALFONTS);
//
// Now we consider the fonts individually, and store all acceptable
// ones in the local font list.
//
FHConsiderAllLocalFonts();
cFonts = g_fhFonts->fhNumFonts; if (cFonts) { FHSortAndIndexLocalFonts(); } else { WARNING_OUT(( "No fonts found - this seems unlikely")); }
DC_EXIT_POINT: DebugExitDWORD(FH_Init, cFonts); return(cFonts);}
//
// FH_Term()
//
void FH_Term(void){ DebugEntry(FH_Term);
if (g_fhFonts) { delete g_fhFonts; g_fhFonts = NULL; }
DebugExitVOID(FH_Term);}
//
// FH_ReceivedPacket - see fh.h
//
void ASShare::FH_ReceivedPacket( ASPerson * pasPerson, PS20DATAPACKET pPacket){ PFHPACKET pFontsPacket; UINT iLocal; UINT iRemote; LPNETWORKFONT pRemoteFont; POEREMOTEFONT pLocalFont; UINT cbSize;
DebugEntry(ASShare::FH_ReceivedPacket);
ValidatePerson(pasPerson);
pFontsPacket = (PFHPACKET)pPacket;
//
// If the number we received isn't the same as before, we need to
// possibly free the previous font block, and then allocate a new one.
//
// Once we're in a share with this person, every new joiner will cause
// existing members to resend their local fonts, usually the same size.
// So we can optimize and not realloc in that case.
//
if (pFontsPacket->cFonts != pasPerson->oecFonts) { if (pasPerson->poeFontInfo) { delete[] pasPerson->poeFontInfo; pasPerson->poeFontInfo = NULL; pasPerson->oecFonts = 0; } else { ASSERT(!pasPerson->oecFonts); }
//
// Allocate a new block
//
pasPerson->poeFontInfo = new OEREMOTEFONT[pFontsPacket->cFonts]; if (!pasPerson->poeFontInfo) { ERROR_OUT(("Couldn't allocate %d fonts for FH packet from [%d]", pasPerson->mcsID)); DC_QUIT; }
ZeroMemory(pasPerson->poeFontInfo, pFontsPacket->cFonts * sizeof(OEREMOTEFONT)); pasPerson->oecFonts = pFontsPacket->cFonts; }
TRACE_OUT(("Received %d remote fonts in packet from person [%d]", pasPerson->oecFonts, pasPerson->mcsID));
//
// Consider each remote font. The multibyte fields of the NETWORKFONT
// structure are flipped as they are read; otherwise we would have to
// duplicate the logic about which fields are present in which version.
//
//
// The size of each font is in the packet.
//
cbSize = pFontsPacket->cbFontSize; pRemoteFont = pFontsPacket->aFonts; pLocalFont = pasPerson->poeFontInfo;
for (iRemote = 0; iRemote < pasPerson->oecFonts; iRemote++, pLocalFont++) { //
// Copy the fields we store directly.
//
pLocalFont->rfFontFlags = pRemoteFont->nfFontFlags; pLocalFont->rfAveWidth = pRemoteFont->nfAveWidth; pLocalFont->rfAveHeight = pRemoteFont->nfAveHeight; pLocalFont->rfAspectX = pRemoteFont->nfAspectX; pLocalFont->rfAspectY = pRemoteFont->nfAspectY;
//
// And the R2.0 field(s)...
//
if (m_oeCombinedOrderCaps.capsfFonts & CAPS_FONT_CODEPAGE) { pLocalFont->rfCodePage = pRemoteFont->nfCodePage; } //
// And the other R2.0 field(s)...
//
if (m_oeCombinedOrderCaps.capsfFonts & CAPS_FONT_R20_SIGNATURE) { pLocalFont->rfSigFats = pRemoteFont->nfSigFats; pLocalFont->rfSigThins = pRemoteFont->nfSigThins; pLocalFont->rfSigSymbol = pRemoteFont->nfSigSymbol; } if (m_oeCombinedOrderCaps.capsfFonts & CAPS_FONT_EM_HEIGHT) { pLocalFont->rfMaxAscent = pRemoteFont->nfMaxAscent; TRACE_OUT(( "maxAscent %hd", pLocalFont->rfMaxAscent)); }
//
// Set up an initial remote to local handle mapping, by scanning
// for the first local font with the remote font's facename.
//
// We first set a default match value, in case we dont find a true
// match - this value should never be referenced since we never get
// sent fonts that we can't match (because we sent details of our
// fonts to remote systems, and they should be using the same, or a
// compatible, font matching algorithm.
//
// The mapping we obtain here is to the first local font that has
// the remote font's facename, which is probably not the correct
// font (ie there are probably multiple fonts with the same
// facename). This initial mapping will be updated when we do the
// full matching for all remote fonts. (See FHConsiderRemoteFonts
// for details), but is sufficient, as all we will use it for until
// then, is to obtain the facename.
//
// This approach means that we do not have to store the remote
// facename, which is a useful saving on remote font details space.
//
// SFR5279: cannot default to zero because that means we give a
// name to fonts that do not in fact match at all, causing us to
// always waste effort in FHConsiderRemoteFonts and sometimes to
// wrongly match two fonts that do not really match at all.
//
pLocalFont->rfLocalHandle= NO_FONT_MATCH;
for (iLocal = 0; iLocal < g_fhFonts->fhNumFonts; iLocal++) { if (!lstrcmp(g_fhFonts->afhFonts[iLocal].Details.nfFaceName, pRemoteFont->nfFaceName)) { pLocalFont->rfLocalHandle = (TSHR_UINT16)iLocal; break; } }
//
// Advance to the next remote font.
//
pRemoteFont = (LPNETWORKFONT)((LPBYTE)pRemoteFont + cbSize); }
DC_EXIT_POINT: //
// We have a new set of fonts, so determine the common list.
//
FH_DetermineFontSupport();
DebugExitVOID(ASShare::FH_ReceivedPacket);}
//
// FH_SendLocalFontInfo()
//
void ASShare::FH_SendLocalFontInfo(void){ PFHPACKET pFontPacket = NULL; LPBYTE pNetworkFonts; UINT pktSize; UINT iFont; BOOL fSendFont; UINT cDummyFonts = 0;#ifdef _DEBUG
UINT sentSize;#endif // _DEBUG
DebugEntry(ASShare::FH_SendLocalFontInfo);
ASSERT(!m_fhLocalInfoSent);
//
//
// Look at the combined capability flags to see whether the remote(s)
// can cope with our preferred font structure (R20) or a slightly
// older one (R11) or only the original flavor (pre R11).
//
//
if (!(m_oeCombinedOrderCaps.capsfFonts & CAPS_FONT_R20_TEST_FLAGS)) { WARNING_OUT(("Remotes in share don't support CAPS_FONT_R20")); m_fhLocalInfoSent = TRUE; DC_QUIT; }
pktSize = sizeof(FHPACKET) + (g_fhFonts->fhNumFonts - 1) * sizeof(NETWORKFONT); pFontPacket = (PFHPACKET)SC_AllocPkt(PROT_STR_MISC, g_s20BroadcastID, pktSize); if (!pFontPacket) { WARNING_OUT(("Failed to alloc FH packet, size %u", pktSize)); DC_QUIT; }
//
// Packet successfully allocated. Fill in the data and send it.
//
pFontPacket->header.data.dataType = DT_FH;
pFontPacket->cbFontSize = sizeof(NETWORKFONT);
//
// Copy the fonts we want to send into the network packet.
//
pNetworkFonts = (LPBYTE)pFontPacket->aFonts; cDummyFonts = 0; for (iFont = 0 ; iFont < g_fhFonts->fhNumFonts ; iFont++) { //
// Assume we will send this font.
//
fSendFont = TRUE;
//
// Check whether font is ANSI charset or font CodePage capability
// is supported. If neither, skip on to next local font.
//
TRACE_OUT(( "TEST CP set OK: font[%u] CodePage[%hu]", iFont, g_fhFonts->afhFonts[iFont].Details.nfCodePage));
if ((g_fhFonts->afhFonts[iFont].Details.nfCodePage != ANSI_CHARSET) && (!(m_oeCombinedOrderCaps.capsfFonts & CAPS_FONT_CODEPAGE)) ) { TRACE_OUT(( "Dont send font[%u] CodePage[%hu]", iFont, g_fhFonts->afhFonts[iFont].Details.nfCodePage)); fSendFont = FALSE; }
if (fSendFont) { //
// We want to send this entry so copy across as much of the
// stored details as the protocol level requires.
// We then mask the flags and advance to the next location in
// the packet.
//
memcpy(pNetworkFonts, &g_fhFonts->afhFonts[iFont].Details, sizeof(NETWORKFONT));
((LPNETWORKFONT)pNetworkFonts)->nfFontFlags &= ~NF_LOCAL; } else { //
// If we determine that we do not want to send the current
// font then we fill the corresponding entry in the network
// packet with zeros. This ensures that an index into our
// local font table is also an index into the network packet,
// so no conversion is required. Setting the whole entry to
// zero gives the font a NULL facename and zero size, which
// will never match a real font.
//
ZeroMemory(pNetworkFonts, sizeof(NETWORKFONT)); cDummyFonts++; }
//
// Move to the next entry in the font packet.
//
pNetworkFonts += sizeof(NETWORKFONT); }
//
// Note that at the end of this loop, we may not have sent any fonts,
// eg where the remote system does not support the font CodePage
// capability and we do not have any true ANSI fonts. We send the
// packet anyway, so the remote system sees that we have no fonts to
// match.
//
//
// Only now do we know the number of fonts we actually put in the
// packet.
//
pFontPacket->cFonts = (TSHR_UINT16)g_fhFonts->fhNumFonts;
//
// Send the fonts packet on the MISC stream. It has no dependency on
// any updates and we want it to get across quickly.
//
if (m_scfViewSelf) FH_ReceivedPacket(m_pasLocal, &(pFontPacket->header));
#ifdef _DEBUG
sentSize =#endif // _DEBUG
DCS_CompressAndSendPacket(PROT_STR_MISC, g_s20BroadcastID, &(pFontPacket->header), pktSize);
TRACE_OUT(("FH packet size: %08d, sent %08d", pktSize, sentSize)); TRACE_OUT(( "Sent font packet with %u fonts (inc %u dummies)", g_fhFonts->fhNumFonts, cDummyFonts));
//
// Set the flag that indicates that we have successfully sent the
// font info.
//
m_fhLocalInfoSent = TRUE;
//
// The font info has been sent, so this may mean we can enable text
// orders.
//
FHMaybeEnableText();
DC_EXIT_POINT: DebugExitVOID(ASShare::FH_SendLocalFontInfo);}
//
// FUNCTION: FH_GetMaxHeightFromLocalHandle
//
// DESCRIPTION:
//
// Given an FH font handle (ie a handle originating from the locally
// supported font structure which was sent to the remote machine at the
// start of the call) this function returns the MaxBaseLineExt value stored
// with the LOCALFONT details
//
// PARAMETERS:
//
// fontHandle - font handle being queried.
//
// RETURNS: max font height
//
//
UINT FH_GetMaxHeightFromLocalHandle(UINT fontHandle){ UINT rc;
DebugEntry(FH_GetMaxHeightFromLocalHandle);
//
// First check that the font handle is valid.
//
if (fontHandle >= g_fhFonts->fhNumFonts) { ERROR_OUT(( "Invalid font handle %u", fontHandle)); fontHandle = 0; }
//
// Return the max font height
//
rc = g_fhFonts->afhFonts[fontHandle].lMaxBaselineExt;
DebugExitDWORD(FH_GetMaxHeightFromLocalHandle, rc); return(rc);}
//
// FUNCTION: FH_GetFontFlagsFromLocalHandle
//
// DESCRIPTION:
//
// Given an FH font handle (ie a handle originating from the locally
// supported font structure which was sent to the remote machine at the
// start of the call) this function returns the FontFlags value stored with
// the LOCALFONT details
//
// PARAMETERS:
//
// fontHandle - font handle being queried.
//
// RETURNS: font flags
//
//
UINT FH_GetFontFlagsFromLocalHandle(UINT fontHandle){ UINT rc;
DebugEntry(FH_GetFontFlagsFromLocalHandle);
//
// First check that the font handle is valid.
//
if (fontHandle >= g_fhFonts->fhNumFonts) { ERROR_OUT(( "Invalid font handle %u", fontHandle)); fontHandle = 0; }
//
// Return the font flags.
//
rc = g_fhFonts->afhFonts[fontHandle].Details.nfFontFlags;
DebugExitDWORD(FH_GetFontFlagsFromLocalHandle, rc); return(rc);}
//
// FUNCTION: FH_GetCodePageFromLocalHandle
//
// DESCRIPTION:
//
// Given an FH font handle (ie a handle originating from the locally
// supported font structure which was sent to the remote machine at the
// start of the call) this function returns the CodePage value stored with
// the LOCALFONT details
//
// PARAMETERS:
//
// fontHandle - font handle being queried.
//
// RETURNS: char set
//
//
UINT FH_GetCodePageFromLocalHandle(UINT fontHandle){ UINT rc = 0;
DebugEntry(FH_GetCodePageFromLocalHandle);
//
// First check that the font handle is valid.
//
if (fontHandle >= g_fhFonts->fhNumFonts) { ERROR_OUT(( "Invalid font handle %u", fontHandle)); fontHandle = 0; }
//
// Return the char set.
//
rc = g_fhFonts->afhFonts[fontHandle].Details.nfCodePage;
DebugExitDWORD(FH_GetCodePageFromLocalHandle, rc); return(rc);}
//
// FH_ConvertAnyFontIDToLocal()
//
// DESCRIPTION:
// Converts any font name ID fields in the passed order from remote font
// face name IDs to local font facename IDs.
//
void ASShare::FH_ConvertAnyFontIDToLocal( LPCOM_ORDER pOrder, ASPerson * pasPerson){ LPCOMMON_TEXTORDER pCommon = NULL;
DebugEntry(ASShare::FH_ConvertAnyFontIDToLocal);
ValidatePerson(pasPerson);
//
// Get a pointer to the structure which is common to both TextOut and
// ExtTextOut
//
if (TEXTFIELD(pOrder)->type == LOWORD(ORD_TEXTOUT)) { pCommon = &TEXTFIELD(pOrder)->common; } else if (EXTTEXTFIELD(pOrder)->type == LOWORD(ORD_EXTTEXTOUT)) { pCommon = &EXTTEXTFIELD(pOrder)->common; } else { ERROR_OUT(( "Order type not TextOut or ExtTextOut.")); DC_QUIT; }
TRACE_OUT(( "fonthandle IN %lu", pCommon->FontIndex)); pCommon->FontIndex = FHGetLocalFontHandle(pCommon->FontIndex, pasPerson); TRACE_OUT(( "fonthandle OUT %lu", pCommon->FontIndex));
DC_EXIT_POINT: DebugExitVOID(ASShare::FH_ConvertAnyFontIDToLocal);}
//
// FH_GetFaceNameFromLocalHandle - see fh.h
//
LPSTR FH_GetFaceNameFromLocalHandle(UINT fontHandle, LPUINT pFaceNameLength){ LPSTR pFontName = NULL;
DebugEntry(FH_GetFaceNameFromLocalHandle);
//
// First check that the font handle is valid.
//
if (fontHandle >= g_fhFonts->fhNumFonts) { ERROR_OUT(( "Invalid font handle %u", fontHandle)); fontHandle = 0; }
//
// Now get the facename
//
*pFaceNameLength = lstrlen(g_fhFonts->afhFonts[fontHandle].RealName); pFontName = g_fhFonts->afhFonts[fontHandle].RealName;
DebugExitVOID(FH_GetFaceNameFromLocalHandle); return(pFontName);}
//
// FH_DetermineFontSupport()
//
void ASShare::FH_DetermineFontSupport(void){ UINT cCommonFonts; UINT iLocal; ASPerson * pasPerson;
DebugEntry(ASShare::FH_DetermineFontSupport);
//
// First mark all local fonts as supported.
//
cCommonFonts = g_fhFonts->fhNumFonts; for (iLocal = 0; iLocal < g_fhFonts->fhNumFonts; iLocal++) { g_fhFonts->afhFonts[iLocal].SupportCode = FH_SC_EXACT_MATCH; }
//
// Work through all remote people (but not us)
//
ValidatePerson(m_pasLocal);
for (pasPerson = m_pasLocal->pasNext; (cCommonFonts > 0) && (pasPerson != NULL); pasPerson = pasPerson->pasNext) { ValidatePerson(pasPerson);
if (pasPerson->oecFonts) { cCommonFonts = FHConsiderRemoteFonts(cCommonFonts, pasPerson); } else { //
// We do not have valid fonts for this person, so must not
// send any text orders at all.
//
TRACE_OUT(( "Pending FONT INFO from person [%d]", pasPerson->mcsID)); cCommonFonts = 0; } }
//
// We have determined the common supported fonts, and may be able to
// enable text orders now.
//
FHMaybeEnableText();
DebugExitVOID(ASShare::FH_DetermineFontSupport);}
//
// FH_CreateAndSelectFont()
//
BOOL FH_CreateAndSelectFont(HDC surface, HFONT* pHNewFont, HFONT* pHOldFont, LPSTR fontName, UINT codepage, UINT fontMaxHeight, UINT fontHeight, UINT fontWidth, UINT fontWeight, UINT fontFlags){ BOOL rc; BYTE italic; BYTE underline; BYTE strikeout; BYTE pitch; BYTE charset; BYTE precis;
DebugEntry(FH_CreateAndSelectFont);
//
// Set the return code to indicate failure (FALSE). We will change this
// later if we successfully create the font.
//
rc = FALSE;
//
// Massage the data passed which describes the font into the correct
// arrangement to pass on a create font call. Then create a font.
//
//
// If a facename passed is the null string then we are supposed to use
// the system font.
//
if (fontName[0] == 0) { WARNING_OUT(( "Using system font")); *pHNewFont = GetStockFont(SYSTEM_FONT); } else { //
// Determine the italic, underline, strikeout and pitch values from
// the packed flags.
//
italic = (BYTE)(fontFlags & NF_ITALIC); underline = (BYTE)(fontFlags & NF_UNDERLINE); strikeout = (BYTE)(fontFlags & NF_STRIKEOUT);
if (fontFlags & NF_FIXED_PITCH) { pitch = FF_DONTCARE | FIXED_PITCH; } else { pitch = FF_DONTCARE | VARIABLE_PITCH; }
//
// Check whether this is a TrueType font. This is important, as
// the Windows Font mapper is biased towards non-TrueType, and it
// is easy to do the subsequent decoding with a non-TrueType font.
//
// Note that the Windows headers do not define a name for the
// required value (which is 0x04 in the manuals), so we use the
// value used in the TextMetrics (which has the same value).
//
if (fontFlags & NF_TRUE_TYPE) { pitch |= TMPF_TRUETYPE; precis = OUT_TT_ONLY_PRECIS; } else { precis = OUT_RASTER_PRECIS; }
//
// The height we are passed is the character height, not the cell
// height. To indicate this to Windows we need to pass it in as a
// negative value.
//
TRACE_OUT(( "CreateFont cx(%u) cy(%u) wt(%u) pitch(%u) name:%s", fontWidth, fontHeight, fontWeight, pitch, fontName ));
//
// Use the misleadingly named codepage value to calculate what
// charset to ask Windows for.
//
if (codepage == NF_CP_WIN_ANSI) { charset = ANSI_CHARSET; } else if (codepage == NF_CP_WIN_OEM) { charset = OEM_CHARSET; } else if (codepage == NF_CP_WIN_SYMBOL) { charset = SYMBOL_CHARSET; } else { //
// We have to trust our luck to Windows by specifying default
// (meaning don't care).
//
charset = DEFAULT_CHARSET; }
*pHNewFont = CreateFont(-(int)fontHeight, fontWidth, 0, // escapement
0, // orientation
fontWeight, italic, underline, strikeout, charset, precis, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, pitch, fontName); if (*pHNewFont == NULL) { WARNING_OUT(( "Failed to create font %s", fontName)); DC_QUIT; } }
//
// Now we have created the font we need to select it into the HDC
// which was passed to us.
//
*pHOldFont = SelectFont(surface, *pHNewFont); if (*pHOldFont == NULL) { ERROR_OUT(( "Failed to select font %s", fontName)); DeleteFont(*pHNewFont); *pHNewFont = NULL; DC_QUIT; } TRACE_OUT(( "Select new font: %p Old font: %", *pHNewFont, *pHOldFont));
//
// We have successfully created and selected the font.
//
rc = TRUE;
DC_EXIT_POINT: DebugExitDWORD(FH_CreateAndSelectFont, rc); return(rc);}
//
// FHAddFontToLocalTable
//
// Adds the given font into the local font table, along with any renaming
// and approximate matches.
//
//
void FHAddFontToLocalTable( LPSTR faceName, TSHR_UINT16 fontFlags, TSHR_UINT16 codePage, TSHR_UINT16 maxHeight, TSHR_UINT16 aveHeight, TSHR_UINT16 aveWidth, TSHR_UINT16 aspectX, TSHR_UINT16 aspectY, TSHR_UINT16 maxAscent){ TSHR_INT16 fatSig; TSHR_INT16 thinSig; TSHR_INT16 symbolSig; FHWIDTHTABLE wTable; TSHR_UINT16 height; TSHR_UINT16 width; TSHR_UINT16 weight; LOCALFONT thisFont; TSHR_UINT16 fIndex;
//
// SFRFONT: place marker.
// Here would be the best place to adjust codepage; for example suppose
// we find that CodePage 950 (Chinese) is so different on all platforms
// that we just should not send text orders in this codepage, we can
// set codePage=NF_CP_UNKNOWN and it will be discarded.
//
//
// SFRFONT: no point hanging on to details of fonts with unknown
// code pages; we cannot risk matching them.
//
if (codePage == NF_CP_UNKNOWN) { TRACE_OUT(( "unknown CP: discard")); DC_QUIT; }
//
// Check we still have room for more fonts.
//
if (g_fhFonts->fhNumFonts >= FH_MAX_FONTS) { //
// We are already at our maximum number of fonts.
//
DC_QUIT; }
//
// Zero the fields where we store facenames to allow bytewise matches.
//
ZeroMemory(thisFont.Details.nfFaceName, FH_FACESIZE); ZeroMemory(thisFont.RealName, FH_FACESIZE);
//
// Store the easy bits!
//
thisFont.Details.nfFontFlags = fontFlags; thisFont.Details.nfAveWidth = aveWidth; thisFont.Details.nfAveHeight = aveHeight; thisFont.Details.nfAspectX = aspectX; thisFont.Details.nfAspectY = aspectY; thisFont.Details.nfCodePage = codePage;
thisFont.lMaxBaselineExt = maxHeight;
//
// Store the real name, for use when we want to create an instance of
// this font.
//
lstrcpy (thisFont.RealName, faceName);
//
// Fill in the wire-format facename.
//
// NB - This has a machine-specific prefix, but for NT the prefix is an
// empty string, so we can just use a strcpy without worrying about the
// issues of adding a prefix.
//
lstrcpy (thisFont.Details.nfFaceName, faceName);
//
// Make sure the signatures are zero for now.
//
thisFont.Details.nfSigFats = 0; thisFont.Details.nfSigThins = 0; thisFont.Details.nfSigSymbol = 0;
//
// Now calculate the signature and maxAscent for this font
//
weight = 0; // use default weight
if ((fontFlags & NF_FIXED_SIZE) != 0) { //
// Fixed size font: use actual font size for signatures/maxAscent
//
height = thisFont.lMaxBaselineExt; width = thisFont.Details.nfAveWidth;
thisFont.Details.nfMaxAscent = maxAscent; } else { //
// Scalable font: use default height/width for signatures/maxAscent
//
height = NF_METRICS_HEIGHT; width = NF_METRICS_WIDTH;
thisFont.Details.nfMaxAscent = NF_METRICS_HEIGHT; }
//
// Initialise signature fields to zero (== NF_NO_SIGNATURE). They will
// be overwritten assuming we get a font width table OK.
//
fatSig = 0; thinSig = 0; symbolSig = 0;
//
// FHGenerateFontWidthTable also gives us a proper maxAscent value for
// scalable fonts (i.e. based on its own rendition of the font)
//
if (FHGenerateFontWidthTable(&wTable, &thisFont, height, width, weight, thisFont.Details.nfFontFlags, &maxAscent)) { //
// If this is a scalable font, use the updated maxAscent value that
// FHGenerateFontWidthTable has given us.
//
if (0 == (thisFont.Details.nfFontFlags & NF_FIXED_SIZE)) { thisFont.Details.nfMaxAscent = maxAscent; TRACE_OUT(( "Set maxAscent = %d", thisFont.Details.nfMaxAscent)); }
//
// We have all the raw data we need. Calculate the signatures.
//
FHCalculateSignatures(&wTable, &fatSig, &thinSig, &symbolSig); }
//
// Store the signatures. If the call to FHGenerateFontWidthTable
// fails, the signatures are zero.
//
thisFont.Details.nfSigFats = (BYTE)fatSig; thisFont.Details.nfSigThins = (BYTE)thinSig; thisFont.Details.nfSigSymbol = (TSHR_UINT16)symbolSig;
TRACE_OUT(( "Font %hu signatures: (x%.4hx%.2hx%.2hx)", g_fhFonts->fhNumFonts, thisFont.Details.nfSigSymbol, (TSHR_UINT16)(thisFont.Details.nfSigThins), (TSHR_UINT16)(thisFont.Details.nfSigFats)));
//
// We can now copy the details to the end of the local table.
//
memcpy((void *)&g_fhFonts->afhFonts[g_fhFonts->fhNumFonts], (void *)&thisFont, sizeof(LOCALFONT));
//
// Count this font.
//
TRACE_OUT(( "Added record %s", g_fhFonts->afhFonts[g_fhFonts->fhNumFonts].Details.nfFaceName)); g_fhFonts->fhNumFonts++;
TRACE_OUT(( "g_fhFonts->fhNumFonts now %u", g_fhFonts->fhNumFonts));
DC_EXIT_POINT: DebugExitVOID(FHAddFontToLocalTable);}
//
// FHConsiderRemoteFonts
//
// Considers the remote fonts for a single remote person.
//
// Takes the existing number of supported fonts, and returns the number
// that are still common after considering this person.
//
UINT ASShare::FHConsiderRemoteFonts( UINT cCanSend, ASPerson * pasPerson){ UINT iLocal; UINT iRemote; UINT cCanReceive=0; BOOL fCanReceive, fOnlyAscii; UINT sendSupportCode; UINT bestSupportSoFar;
DebugEntry(ASShare::FHConsiderRemoteFonts);
ValidatePerson(pasPerson); //
// Consider each of the still valid local fonts, and see if the remote
// person also supports them.
//
//
// SFR5396: LOOP ONE
//
// Look through all the LOCAL fonts, for ones where we find a match in
// the remote font table. These are fonts we can SEND, and for which
// we must set g_fhFonts->afhFonts[].Supported.
//
// We also set the rfLocalHandle for remote fonts that we can receive
// if we encounter them in this search. We complete the search for
// remote fonts that we can receive in LOOP TWO.
//
// Things we check in this loop: - we may already know there is no
// match for this local name
// so drop out quickly. - otherwise check through EVERY REMOTE
// font looking for the
// best possible match. (If we find an EXACT match, leave the
// inner loop early)
//
//
for (iLocal=0; (cCanSend > 0) && (iLocal < g_fhFonts->fhNumFonts); iLocal++) { if (g_fhFonts->afhFonts[iLocal].SupportCode != FH_SC_NO_MATCH) { //
//
// This font is still valid so check it with all the remote
// fonts for this person.
//
// Things we check in this loop:
// - do the face names match? if no - try next remote font.
// - the pitch: if one is FIXED pitch and one isn't try next
// - the codepages: are the local/remote the same? This
// determines whether we send only ASCII chars.
// - scalability: possible combinations are:
// local fixed/remote scalable (can send/not rcv)
// local scalable/remote scalable (can send and rcv)
// local fixed/remote fixed, sizes match (send & rcv)
// local scalable/remote fixed (cannot send/can rcv)
// for this last case, keep trying the remote fonts.
//
// In "back level" calls to Pre-R11 boxes we stop here but
// force the matches to be approximate. Otherwise check
//
// - aspect ratios (if present): must match or try the
// next remote font.
// - signatures: these are used to finally decide whether
// the fonts are exact matches; good enough to treat as
// approximate matches or such poor matches that the
// font is not supported (cannot be sent).
//
//
//
// Handy SHORTHAND macroes.
//
#define REMOTEFONT pasPerson->poeFontInfo[iRemote]
#define LOCALFT g_fhFonts->afhFonts[iLocal]
#define LOCALDETS LOCALFT.Details
//
// Initially assume that the fonts do not match, but that
// if they do they will match across the whole codepage
// (not just the ascii set).
//
sendSupportCode = FH_SC_NO_MATCH; bestSupportSoFar = FH_SC_NO_MATCH; fOnlyAscii = FALSE;
//
//
// Loop through all the remote fonts looking to see which, if
// any, offers the best possible match. Initially,
// sendSupportCode is set to NO_MATCH; as we go through each
// iteration we see if we can improve on the current setting
// of sendSupportCode. We leave the loop as soon as we find
// an EXACT_MATCH ('cos we are not going to do any better than
// that!) or when we run out of remote fonts. The best match
// found so far is kept in bestSupportSoFar.
//
//
for (iRemote = 0; (iRemote < pasPerson->oecFonts) && (sendSupportCode != FH_SC_EXACT_MATCH); iRemote++) { //
// If the remote font is already flagged as having no
// possible match then skip out now. (We set this field
// during the initial processing of the remote font).
//
if (REMOTEFONT.rfLocalHandle==NO_FONT_MATCH) { continue; // SFR5279
}
//
// Check the face names...
//
if (lstrcmp(LOCALDETS.nfFaceName, g_fhFonts->afhFonts[REMOTEFONT.rfLocalHandle].Details.nfFaceName)) { continue; } TRACE_OUT(( "Matched Remote Face Name %s", g_fhFonts->afhFonts[REMOTEFONT.rfLocalHandle] .Details.nfFaceName));
//
// Check the pitch...
//
if( (LOCALDETS.nfFontFlags & NF_FIXED_PITCH)!= (REMOTEFONT.rfFontFlags & NF_FIXED_PITCH) ) { TRACE_OUT(( "Different Pitch %x %x", LOCALDETS.nfFontFlags, REMOTEFONT.rfFontFlags)); continue; }
//
//
// If both systems support the font CodePage capability
// (indicated by the remote capability flags - which are
// the union of remote and local by now), check that the
// CodePages and CodePage flags match, and if not,
// restrict ourselves to sending the ASCII subset.
//
// If we support the font CodePage capability but remote
// system does not, then restrict ourselves to sending the
// ASCII subset.
//
// If we do not support the font CodePage capability, then
// we assume that the remote is only sending ANSI CodePage,
// either because it doesn't know about the font CodePage
// capability or because it can see that we don't support
// it. Therefore, we do not need to check the CodePage.
// BUT: restrict ourselves to ASCII only.
//
//
if (!(m_pasLocal->cpcCaps.orders.capsfFonts & CAPS_FONT_CODEPAGE)) { //
// We do not support codepage checking.
//
TRACE_OUT(( "not checking CP")); fOnlyAscii = TRUE; }
if ((m_oeCombinedOrderCaps.capsfFonts & CAPS_FONT_CODEPAGE) && (LOCALDETS.nfCodePage != REMOTEFONT.rfCodePage) ) { TRACE_OUT(( "Different CPs %hu %hu", LOCALDETS.nfCodePage, REMOTEFONT.rfCodePage)); //
//
// Assume that all codepages include ASCII.
//
//
fOnlyAscii = TRUE; }
//
//
// If we support codepage, but the remote does not then
// the remote will only be sending us ANSI chars. Make sure
// that we send only ASCII subset.
//
//
if ((m_pasLocal->cpcCaps.orders.capsfFonts & CAPS_FONT_CODEPAGE) && !(m_oeCombinedOrderCaps.capsfFonts & CAPS_FONT_CODEPAGE)) { TRACE_OUT(( "Only ASCII")); fOnlyAscii = TRUE; }
//
//
// The face names and CodePages match and the fonts are of
// the same type of pitch (ie both are fixed pitch or both
// are variable pitch).
//
//
if ((REMOTEFONT.rfFontFlags & NF_FIXED_SIZE) == 0) { //
//
// The remote font is scalable, so we can send any font
// (with this facename) to the remote system, even if
// the local font is fixed sized. Set sendSupportCode
// to FH_SC_EXACT_MATCH now - we will change this to
// FH_SC_APPROX_MATCH later if other fields differ.
//
//
TRACE_OUT(( "Person [%d] Can SEND: remote SCALABLE %s (remote)%u to (local)%u", pasPerson->mcsID, LOCALDETS.nfFaceName, iRemote, iLocal)); sendSupportCode = FH_SC_EXACT_MATCH;
//
//
// SFR5396: it is true that we can SEND this font
// because the remote version of the font is scalable.
// That does not mean that we can necessarily receive
// the font... unless ours is scalable too.
//
//
if ((LOCALDETS.nfFontFlags & NF_FIXED_SIZE)==0) { TRACE_OUT(( "Person [%d] Can RECEIVE remote font %u as local %u", pasPerson->mcsID, iRemote, iLocal)); REMOTEFONT.rfLocalHandle = (TSHR_UINT16)iLocal; } } else if (LOCALDETS.nfFontFlags & NF_FIXED_SIZE) { //
//
// The remote font is fixed size and so is the local
// one, so check if the sizes match exactly.
//
//
if ((LOCALDETS.nfAveWidth == REMOTEFONT.rfAveWidth) && (LOCALDETS.nfAveHeight == REMOTEFONT.rfAveHeight)) { //
//
// Our fixed size local font is the same as the
// fixed size font at the remote. We set
// sendSupportCode to FH_SC_EXACT_MATCH now - we
// will change this to FH_SC_APPROX_MATCH later if
// other fields differ.
//
//
TRACE_OUT(("Person [%d] Matched remote fixed font %s %u to %u", pasPerson->mcsID, LOCALDETS.nfFaceName, iRemote, iLocal)); sendSupportCode = FH_SC_EXACT_MATCH; REMOTEFONT.rfLocalHandle = (TSHR_UINT16)iLocal; } else { TRACE_OUT(( "rejected %s ave width/heights " "local/remote width %d/%d height %d/%d", LOCALDETS.nfFaceName, LOCALDETS.nfAveWidth, REMOTEFONT.rfAveWidth, LOCALDETS.nfAveHeight, REMOTEFONT.rfAveHeight)); } } else { TRACE_OUT(( "Can only RECEIVE %s %u Remote is fixed, but local %u not", LOCALDETS.nfFaceName, iRemote, iLocal)); //
//
// SFR5396: while we cannot SEND this font because our
// local version is scalable, but the remote's is
// fixed - we can still receive the font in an order.
//
//
REMOTEFONT.rfLocalHandle = (TSHR_UINT16)iLocal; }
//
//
// If we have have set the send support code to indicate
// that we have matched we now consider any R1.1 info if it
// is present. As a result of this we may adjust the send
// support code (from indicating an exact match) to
// indicate either an approximate match or no match at all.
//
//
if (!pasPerson->oecFonts) { //
//
// The remote system did not send us any R11 font
// info. In this case we assume all font matches are
// approximate and restrict ourselves to the ascii
// subset.
//
//
if (sendSupportCode != FH_SC_NO_MATCH) { TRACE_OUT(( "No R11 so approx match only")); sendSupportCode = FH_SC_APPROX_ASCII_MATCH; } } else if (sendSupportCode != FH_SC_NO_MATCH) { //
//
// The remote system did send us R11 font info and
// the font is flagged as matching.
//
//
if ((m_oeCombinedOrderCaps.capsfFonts & CAPS_FONT_R20_SIGNATURE)!=0) { //
//
// Check the signatures.
//
//
TRACE_OUT(( "Person [%d] local %d (remote %d) signatures (x%.4hx%.2hx%.2hx v x%.4hx%.2hx%.2hx)", pasPerson->mcsID, iLocal, iRemote, LOCALDETS.nfSigSymbol, (TSHR_UINT16)(LOCALDETS.nfSigThins), (TSHR_UINT16)(LOCALDETS.nfSigFats), REMOTEFONT.rfSigSymbol, (TSHR_UINT16)(REMOTEFONT.rfSigThins), (TSHR_UINT16)(REMOTEFONT.rfSigFats)));
if ((LOCALDETS.nfSigFats != REMOTEFONT.rfSigFats) || (LOCALDETS.nfSigThins != REMOTEFONT.rfSigThins) || (LOCALDETS.nfSigSymbol != REMOTEFONT.rfSigSymbol) || (REMOTEFONT.rfSigSymbol == NF_NO_SIGNATURE)) { //
// Decide what to do from the signatures.
//
if (REMOTEFONT.rfSigSymbol == NF_NO_SIGNATURE) { TRACE_OUT(("NO match: remote no signature")); sendSupportCode = FH_SC_APPROX_ASCII_MATCH; } else if ((LOCALDETS.nfSigFats == REMOTEFONT.rfSigFats) && (LOCALDETS.nfSigThins == REMOTEFONT.rfSigThins)) { TRACE_OUT(( "our ASCII sigs match")); sendSupportCode = FH_SC_EXACT_ASCII_MATCH; } else { //
// NOTE:
// We could use the "closeness" of the fat
// and thin signatures to help us decide
// whether to use approximate matching or
// not. But currently we don't.
//
TRACE_OUT(( "Sig mismatch: APPROX_ASC")); sendSupportCode = FH_SC_APPROX_ASCII_MATCH; } } else { //
//
// All signatures match exactly.
// Leave SendSupportCode as FH_SC_EXACT_MATCH
//
//
TRACE_OUT(("EXACT MATCH: Signatures match exactly")); } } else { //
// Not using signatures. Do we care?
//
sendSupportCode = FH_SC_APPROX_MATCH; TRACE_OUT(( "APPROX MATCH: no sigs")); }
//
//
// Check the aspect ratio - but only if we do not
// already know that this font does not match.
//
//
if ( (sendSupportCode!=FH_SC_NO_MATCH) && ( (!(m_oeCombinedOrderCaps.capsfFonts & CAPS_FONT_ASPECT)) || (LOCALDETS.nfAspectX != REMOTEFONT.rfAspectX) || (LOCALDETS.nfAspectY != REMOTEFONT.rfAspectY) )) { //
//
// Either no aspect ratio was supplied or the
// aspect ratio differed.
//
//
if (sendSupportCode == FH_SC_EXACT_MATCH) { //
// Force delta-X text orders for mismatched
// aspect ratio. Note we tested above to
// see whether supportCode == EXACT because if
// we have already "downgraded" support then
// we do not need to change it here
//
sendSupportCode = FH_SC_APPROX_MATCH; TRACE_OUT(( "AR mismatch: APPROX_MATCH")); } else if (sendSupportCode == FH_SC_EXACT_ASCII_MATCH) { //
// Same again but for ASCII only.
//
sendSupportCode = FH_SC_APPROX_ASCII_MATCH; TRACE_OUT(( "AR mismatch: APPROX_ASCII_MATCH")); } } }
if (sendSupportCode != FH_SC_NO_MATCH) { //
//
// Is this a better match than any we have seen
// before?
//
//
switch (sendSupportCode) { case FH_SC_EXACT_MATCH: case FH_SC_APPROX_MATCH: //
//
// Note that we do not have to worry about
// overwriting a bestSupportSoFar of EXACT
// with APPROX because we leave the loop when
// we get an exact match.
//
//
bestSupportSoFar = sendSupportCode; break;
case FH_SC_EXACT_ASCII_MATCH: //
//
// An approximate match over the whole 255
// code points is better than an exact one
// over just the ascii-s. Debatable, but that
// is what I have decided.
//
//
if (bestSupportSoFar != FH_SC_APPROX_MATCH) { bestSupportSoFar = FH_SC_EXACT_ASCII_MATCH; } break;
case FH_SC_APPROX_ASCII_MATCH: //
//
// An approximate match over just the ascii-s
// is better than nothing at all!
//
//
if (bestSupportSoFar == FH_SC_NO_MATCH) { bestSupportSoFar = FH_SC_APPROX_ASCII_MATCH; } break;
default: ERROR_OUT(("invalid support code")); break;
} } }
sendSupportCode = bestSupportSoFar;
//
// If we matched the remote font, we have already updated
// its local handle to
// the matched local font. While the local handle was already
// set up, it was only set up to the first local font with the
// same facename, rather than the correct font.
//
// If we did not match the remote font, mark it as not
// supported, and decrement the common font count.
//
if (sendSupportCode != FH_SC_NO_MATCH) { TRACE_OUT(( "Local font %d/%s can be SENT (code=%u)", iLocal, LOCALDETS.nfFaceName, sendSupportCode)); if (fOnlyAscii) { if (sendSupportCode == FH_SC_EXACT_MATCH) { sendSupportCode = FH_SC_EXACT_ASCII_MATCH; TRACE_OUT(( "Adjust %d/%s to EXACT_ASC (code=%u)", iLocal, LOCALDETS.nfFaceName, sendSupportCode)); } else { TRACE_OUT(( "Adjust %d/%s to APPROX_ASC (code=%u)", iLocal, LOCALDETS.nfFaceName, sendSupportCode)); sendSupportCode = FH_SC_APPROX_ASCII_MATCH; } } } else { TRACE_OUT(( "Local font %d/%s cannot be SENT", iLocal,LOCALDETS.nfFaceName)); cCanSend--; }
LOCALFT.SupportCode &= sendSupportCode; } else { TRACE_OUT(( "Cannot SEND %d/%s",iLocal,LOCALDETS.nfFaceName)); } }
//
//
// SFR5396: LOOP TWO
//
// Loop through all the remote fonts, looking for ones where we have
// a locally matching font. These are fonts that we can RECEIVE in
// orders, and for which we need to map the remote font handle to the
// local font handle. This means setting REMOTEFONT.rfLocalHandle.
//
// By the time we reach here, REMOTEFONT.rfLocalHandle is already set
// to:
// - NO_FONT_MATCH (in FH_ProcessRemoteFonts)
// or the index in the local table of a definite match found in LOOP1
// or the index of the first entry in the local table with the
// same face name as the remote font (set in FH_ProcessRemoteFonts)
//
// so - we can begin our search in the local table from
// REMOTEFONT.rfLocalHandle.
//
//
for (iRemote = 0; (iRemote < pasPerson->oecFonts); iRemote++) { iLocal = REMOTEFONT.rfLocalHandle; if (iLocal == NO_FONT_MATCH) { //
// We have no fonts whatsoever that match this font name
// Go round again... try the next REMOTE font.
//
continue; }
TRACE_OUT(( "Can we receive %s?", g_fhFonts->afhFonts[REMOTEFONT.rfLocalHandle].Details.nfFaceName)); for (fCanReceive = FALSE; (iLocal < g_fhFonts->fhNumFonts) && (!fCanReceive); iLocal++) { //
// Check the face names...
//
if (lstrcmp(LOCALDETS.nfFaceName, g_fhFonts->afhFonts[REMOTEFONT.rfLocalHandle].Details.nfFaceName)) { //
// Try the next LOCAL font.
//
continue; }
//
// Check the pitch...
//
if((LOCALDETS.nfFontFlags & NF_FIXED_PITCH)!= (REMOTEFONT.rfFontFlags & NF_FIXED_PITCH)) { //
// Different pitches, try the next local font.
//
TRACE_OUT(( "Pitch mismatch")); continue; }
//
//
// The face names match and the fonts are of
// the same type of pitch (ie both are fixed pitch or both
// are variable pitch).
//
//
if ((REMOTEFONT.rfFontFlags & NF_FIXED_SIZE) == 0) { if ((LOCALDETS.nfFontFlags & NF_FIXED_SIZE)==0) { //
//
// The remote font is scalable. Ours is also
// scalable then we can receive the font.
//
// We do not need to look at any more LOCAL fonts.
//
//
fCanReceive = TRUE; } } else if (LOCALDETS.nfFontFlags & NF_FIXED_SIZE) { //
//
// The remote font is fixed size and so is the local
// one, so check if the sizes match exactly.
//
//
if ((LOCALDETS.nfAveWidth == REMOTEFONT.rfAveWidth) && (LOCALDETS.nfAveHeight == REMOTEFONT.rfAveHeight)) { //
//
// Our fixed size local font is the same as the
// fixed size font at the remote.
//
// We do not need to look at any more LOCAL fonts.
//
//
fCanReceive = TRUE; } else { TRACE_OUT(( "different fixed sizes")); } } else { //
//
// The remote is FIXED but the LOCAL is scalable. We
// can receive orders for text of this type (but not send)
//
// We do not need to look at any more LOCAL fonts.
//
//
fCanReceive = TRUE; }
if (fCanReceive) { TRACE_OUT(("Person [%d] Can RECEIVE remote font %s %u as %u", pasPerson->mcsID, LOCALDETS.nfFaceName, iRemote, iLocal)); REMOTEFONT.rfLocalHandle = (TSHR_UINT16)iLocal; cCanReceive++; } }
}
TRACE_OUT(("Person [%d] Can SEND %d fonts", pasPerson->mcsID, cCanSend)); TRACE_OUT(("Person [%d] Can RECEIVE %d fonts", pasPerson->mcsID, cCanReceive));
DebugExitDWORD(ASShare::FHConsiderRemoteFonts, cCanSend); return(cCanSend);}
//
// FHMaybeEnableText
//
// Enables or disables sending of text orders
//
void ASShare::FHMaybeEnableText(void){ BOOL fEnableText = FALSE; ASPerson * pasPerson;
DebugEntry(ASShare::FHMaybeEnableText);
//
// To enable sending text orders we must have sent out our own packet
// of fonts, and there must be no outstanding remote packets required.
//
if (m_fhLocalInfoSent) { //
// Assume we can enable text orders.
//
fEnableText = TRUE;
//
// The local info was sent, so check remote dudes (not us)
//
ValidatePerson(m_pasLocal); for (pasPerson = m_pasLocal->pasNext; pasPerson != NULL; pasPerson = pasPerson->pasNext) { ValidatePerson(pasPerson);
if (!pasPerson->oecFonts) { //
// We have found a font packet that we have not yet
// received, so must disable sending text, and can break
// out of the search.
//
TRACE_OUT(( "No font packet yet from person [%d]", pasPerson->mcsID)); fEnableText = FALSE; break; } } } else { TRACE_OUT(( "Local font info not yet sent")); }
OE_EnableText(fEnableText);
if (g_asCanHost) { //
// Pass on new font data to the other tasks.
//
if (fEnableText) { OE_NEW_FONTS newFontData;
//
// Copy the data from the Share Core.
//
newFontData.fontCaps = m_oeCombinedOrderCaps.capsfFonts; newFontData.countFonts = (WORD)g_fhFonts->fhNumFonts; newFontData.fontData = g_fhFonts->afhFonts; newFontData.fontIndex = g_fhFonts->afhFontIndex;
TRACE_OUT(( "Sending %d Fonts", g_fhFonts->fhNumFonts));
//
// Notify display driver of new fonts
//
OSI_FunctionRequest(OE_ESC_NEW_FONTS, (LPOSI_ESCAPE_HEADER)&newFontData, sizeof(newFontData)); } }
DebugExitVOID(ASShare::FHMaybeEnableText);}
//
// FHGetLocalFontHandle
//
// Translate a remote font handle/local ID pair to a local font handle.
//
UINT ASShare::FHGetLocalFontHandle( UINT remotefont, ASPerson * pasPerson){ DebugEntry(ASShare::FHGetLocalFontHandle);
ValidatePerson(pasPerson);
if (!pasPerson->oecFonts) { WARNING_OUT(("Order packet from [%d] but no fonts", pasPerson->mcsID)); }
if (remotefont == DUMMY_FONT_ID) { //
// The dummy font ID has been supplied for the remote font Id.
// Substitute the first valid local font Id.
//
for (remotefont = 0; remotefont < pasPerson->oecFonts; remotefont++) { if (pasPerson->poeFontInfo[remotefont].rfLocalHandle != NO_FONT_MATCH) { break; } } }
if (remotefont >= pasPerson->oecFonts) { //
// The remote font is invalid.
// There is no error value, we simply return the valid but
// incorrect value 0.
//
TRACE_OUT(("Person [%d] Invalid font handle %u", pasPerson->mcsID, remotefont)); return(0); }
DebugExitVOID(ASShare::FHGetLocalFontHandle); return(pasPerson->poeFontInfo[remotefont].rfLocalHandle);}
//
//
// FUNCTION: FHCalculateSignatures
//
// DESCRIPTION:
//
// Given a width table, calculates the three font signatures that are
// included in the R2.0 NETWORKFONT structure.
//
// PARAMETERS:
//
// pTable - pointer to width table
// pSigFats, pSigThins, pSigSymbol - return the three signatures
//
// RETURNS:
//
// None
//
//
void FHCalculateSignatures(PFHWIDTHTABLE pTable, LPTSHR_INT16 pSigFats, LPTSHR_INT16 pSigThins, LPTSHR_INT16 pSigSymbol){ UINT charI = 0; UINT fatSig = 0; UINT thinSig = 0; UINT symbolSig = 0;
DebugEntry(FHCalculateSignatures);
ASSERT((pTable != NULL)); ASSERT((pSigFats != NULL)); ASSERT((pSigThins != NULL)); ASSERT((pSigSymbol != NULL));
//
// nfSigFats the sum of the widths (in pels) of the chars
// 0-9,@-Z,$,%,&. divided by two: the fat chars
// nfSigThins the sum of the widths (in pels) of the chars
// 0x20->0x7F EXCLUDING those summed in nfSigFats.
// Again - divided by two. The thin chars.
// nfSigSymbol The sum of the widths (in pels) of the chars
// x80->xFF.
//
//
// Loop for 0-9, some punctuation, A-Z. Then add $,% and &. i.e. mainly
// fat characters.
//
for (charI= NF_ASCII_ZERO; charI<NF_ASCII_Z ; charI++ ) { fatSig += pTable->charWidths[charI]; } fatSig += pTable->charWidths[NF_ASCII_DOLLAR] + pTable->charWidths[NF_ASCII_PERCENT] + pTable->charWidths[NF_ASCII_AMPERSAND];
//
// thin sig covers the rest of the "ascii" characters (x20->7F) not
// already included in fatSig.
//
for (charI= NF_ASCII_FIRST; charI<NF_ASCII_LAST ; charI++ ) { thinSig += pTable->charWidths[charI]; } thinSig -= fatSig;
//
// symbolSig covers the "non-ascii" characters (x0->1F, 80->FF)
//
for (charI= 0x00; charI<(NF_ASCII_FIRST-1) ; charI++ ) { symbolSig += pTable->charWidths[charI]; } for (charI= NF_ASCII_LAST+1; charI<0xFF ; charI++ ) { symbolSig += pTable->charWidths[charI]; } TRACE_OUT(( "Signatures: symbol %#lx thin %#lx fat %#lx", symbolSig, thinSig, fatSig));
//
// Halve the fat and thin sigs so that they fit into one byte each.
//
fatSig /= 2; thinSig /= 2; if ( (((TSHR_UINT16)symbolSig)==0) && (((BYTE)fatSig)==0) && (((BYTE)thinSig)==0)) { //
// Worry about the faint possibility that all three sums could add
// up to a value of zero when truncated.
//
symbolSig=1; }
//
// Fill in return pointers.
//
*pSigFats = (TSHR_INT16)fatSig; *pSigThins = (TSHR_INT16)thinSig; *pSigSymbol = (TSHR_INT16)symbolSig;
DebugExitVOID(FHCalculateSignatures);}
//
// FHEachFontFamily
//
// This callback is called for each font family. We use it to build up a
// list of all the family names.
//
//
// Although wingdi.h defines the first two parameters for an ENUMFONTPROC
// as LOGFONT and TEXTMETRIC (thereby disagreeing with MSDN), tests show
// that the structures are actually as defined in MSDN (i.e. we get valid
// information when accessing the extended fields)
//
int CALLBACK FHEachFontFamily( const ENUMLOGFONT FAR * enumlogFont, const NEWTEXTMETRIC FAR * TextMetric, int FontType, LPARAM lParam){ LPFHFAMILIES lpFamilies = (LPFHFAMILIES)lParam;
DebugEntry(FHEachFontFamily);
ASSERT(!IsBadWritePtr(lpFamilies, sizeof(*lpFamilies)));
if (lpFamilies->fhcFamilies == FH_MAX_FONTS) { //
// We cannot support any more font families so stop enumerating.
//
WARNING_OUT(( "Can only handle %u families", FH_MAX_FONTS)); return(FALSE); // Stop the enumeration
}
TRACE_OUT(("FHEachFontFamily: %s", enumlogFont->elfLogFont.lfFaceName));
ASSERT(lstrlen(enumlogFont->elfLogFont.lfFaceName) < FH_FACESIZE); lstrcpy(lpFamilies->afhFamilies[lpFamilies->fhcFamilies].szFontName, enumlogFont->elfLogFont.lfFaceName);
lpFamilies->fhcFamilies++;
DebugExitBOOL(FHEachFontFamily, TRUE); return(TRUE); // Continue enumerating
}
//
// FHEachFont
//
// This callback is called for each font. It gathers and stores the font
// details.
//
//
//
// Although wingdi.h defines the first two parameters for an ENUMFONTPROC
// as LOGFONT and TEXTMETRIC (thereby disagreeing with MSDN), tests show
// that the structures are actually as defined in MSDN (i.e. we get valid
// information when accessing the extended fields)
//
int CALLBACK FHEachFont(const ENUMLOGFONT FAR * enumlogFont, const NEWTEXTMETRIC FAR * TextMetric, int FontType, LPARAM lParam){ HDC hdc = (HDC)lParam; TSHR_UINT16 fontflags = 0; TSHR_UINT16 CodePage = 0; HFONT hfont; HFONT holdfont = NULL; TEXTMETRIC tm; BOOL fAcceptFont; int rc;
DebugEntry(FHEachFont);
TRACE_OUT(( "Family name: %s", enumlogFont->elfLogFont.lfFaceName)); TRACE_OUT(( "Full name: %s", enumlogFont->elfFullName));
if (g_fhFonts->fhNumFonts >= FH_MAX_FONTS) { //
// We cannot support any more fonts so stop enumerating.
//
WARNING_OUT(( "Can only handle %u fonts", FH_MAX_FONTS)); rc = 0; DC_QUIT; // Stop the enumeration
}
//
// We want to continue...
//
rc = 1;
//
// Don't bother with this if it's a bold/italic variant.
//
// NOTE:
// The elfFullName field is only valid for TrueType fonts on Win95. For
// non TrueType fonts, assume that the full name and face name are the
// same.
//
if (!g_asWin95 || (FontType & TRUETYPE_FONTTYPE)) { if (lstrcmp(enumlogFont->elfLogFont.lfFaceName, (LPCSTR)enumlogFont->elfFullName)) { TRACE_OUT(( "Discarding variant: %s", enumlogFont->elfFullName)); DC_QUIT; // Jump out, but don't stop enumerating!
} }
//
// We now accumulate information on all local fonts in all CodePages.
// This relies on the subsequent sending of local fonts and matching of
// remote fonts taking into account the CodePage capabilities of the
// systems.
//
//
// On this pass we copy the details into our structure.
//
if (FontType & TRUETYPE_FONTTYPE) { //
// This is a truetype font, which we simply accept without double
// checking its metrics. (Metric double checking to exclude
// duplicates is of most relevance to fixed size fonts, which are
// explicitly optimised for one screen size)
//
fAcceptFont = TRUE;
//
// Indicate TrueType (this will go in the NETWORKFONT structure
// (i.e. over the wire)
//
fontflags |= NF_TRUE_TYPE;
//
// Signal that we did not call CreateFont for this font.
//
hfont = NULL; } else { //
// We create a font from the logical description, and select it so
// that we can query its metrics.
//
// The point of this is that it allows us to identify fonts where
// the logical font description is not a unique description of this
// font, and hence if we cannot get to this font via a logical font
// description, we cannot get to it at all.
//
// If we cannot get to it, then we cannot claim to support it.
//
// This selection operation is SLOW - of the order of a couple of
// seconds in some extreme cases (for example where the font is
// stored on a network drive, and pageing has to take place) and
// when you can have hundreds of fonts this can add up to a
// considerable time.
//
// Hence we only do the selection for non truetype fonts because
// these are the fonts where it is easy to get multiple fonts of
// the same logical description, though designed for different
// display drivers.
//
//
// Create a font from the logical font, so we can see what font
// Windows actually choses.
//
hfont = CreateFontIndirect(&enumlogFont->elfLogFont); holdfont = SelectFont(hdc, hfont);
//
// Find the metrics of the font that Windows has actually selected.
//
GetTextMetrics(hdc, &tm);
//
// Double check the aspect ratios - enumerate returns all fonts,
// but it is possible to have fonts that are never matched by
// Windows due to duplications.
//
fAcceptFont = ((tm.tmDigitizedAspectX == TextMetric->tmDigitizedAspectX) && (tm.tmDigitizedAspectY == TextMetric->tmDigitizedAspectY)); }
//
// Trace out the full text metrics for debugging.
//
if (fAcceptFont) { //
// This font is accepted.
//
//
// Determine the font flags settings.
//
if ((TextMetric->tmPitchAndFamily & TMPF_FIXED_PITCH) == 0) { //
// Setting the TMPF_FIXED_PITCH bit in the text metrics is used
// to indicate that the font is NOT fixed pitch. What a
// wonderfully named bit (see Microsoft CD for explanation).
//
fontflags |= NF_FIXED_PITCH; }
if ((FontType & RASTER_FONTTYPE) || (FontType & TRUETYPE_FONTTYPE) == 0) { //
// This is a raster font, but not a truetype font so it must be
// of fixed size.
//
fontflags |= NF_FIXED_SIZE; }
//
// Get the font CodePage. SFRFONT: must map from CharSet to
// Codepage. For now we only support ANSI and OEM charsets. This
// will need to change to support e.g BiDi/Arabic
//
CodePage = TextMetric->tmCharSet; if (CodePage == ANSI_CHARSET) { TRACE_OUT(( "ANSI codepage")); CodePage = NF_CP_WIN_ANSI; } else if (CodePage == OEM_CHARSET) { TRACE_OUT(( "OEM codepage")); CodePage = NF_CP_WIN_OEM; } else if (CodePage == SYMBOL_CHARSET) { TRACE_OUT(("Symbol codepage")); CodePage = NF_CP_WIN_SYMBOL; } else { TRACE_OUT(( "Charset %hu, unknown codepage", CodePage)); CodePage = NF_CP_UNKNOWN; }
//
//
// SFRFONT: We have replaced the "old" checksum which was based on
// the actual bits making up the font to one based on the widths of
// characters in the font. The intention is that we use this to
// ensure that the actual characters in the local font and in the
// remote font which matches it are all the same width as each
// other.
//
// We calculate this sum for all fonts (not just non-truetype as
// before) because in cross platform calls with approximate font
// matching it applies to fonts of all types.
//
//
//
//
// There is considerable confusion caused by the terminology for
// fonts characteristics. The protocol uses two values MAXHEIGHT
// and AVEHEIGHT. In fact neither of these names is accurate
// (MAXHEIGHT is not the maximum height of a char; and AVEHEIGHT is
// not the average height of all chars).
//
// SFRFONT: we have added maxAscent to the protocol. This is the
// height of a capital letter (such as eM!) PLUS any internal
// leading. This value allows remote boxes to find the baseline -
// the point at which the bottommost pel of a letter with no
// descenders (e.g. capital M) is to be drawn. This is needed
// because not all boxes in the call follow the windows convention
// of specifying the start of text as being the top-left corner of
// the first character cell. maxAscent == tmAscent in the
// TextMetric.
//
//
FHAddFontToLocalTable((LPSTR)enumlogFont->elfLogFont.lfFaceName, (TSHR_UINT16)fontflags, (TSHR_UINT16)CodePage, (TSHR_UINT16)TextMetric->tmHeight, (TSHR_UINT16)(TextMetric->tmHeight - TextMetric->tmInternalLeading), (TSHR_UINT16)TextMetric->tmAveCharWidth, (TSHR_UINT16)TextMetric->tmDigitizedAspectX, (TSHR_UINT16)TextMetric->tmDigitizedAspectY, (TSHR_UINT16)TextMetric->tmAscent); } else { //
// Windows returns a different font when we use this logical font
// description - presumably because of duplicate fonts. We
// therfore must not claim to support this particular font.
//
TRACE_OUT(( "Discarding hidden font %s", enumlogFont->elfLogFont.lfFaceName)); }
if (hfont) { //
// We called CreateFont in processing this font, so now delete it
// to clean up.
//
SelectFont(hdc, holdfont);
//
// We have finished with the font so delete it.
//
DeleteFont(hfont); }
DC_EXIT_POINT: DebugExitDWORD(FHEachFont, rc); return(rc);}
//
// FHConsiderAllLocalFonts
//
// Considers the details of each of the fonts on the local system, and if
// acceptable adds them to the local font list.
//
//
void FHConsiderAllLocalFonts(void){ HDC hdcDesktop; UINT i; LPFONTNAME newFontList; LPFHFAMILIES lpFamilies = NULL;
DebugEntry(FHConsiderAllLocalFonts);
g_fhFonts->fhNumFonts = 0;
//
// We can't enumerate all the fonts directly; we have to enumerate the
// family names, then the fonts within each family.
//
// This alloc assumes the worst case memory-wise (i.e. each
// family contains a single font) and therefore we will usually
// allocate more memory than we need. We use LocalReAlloc later to fix
// this.
//
lpFamilies = new FHFAMILIES; if (!lpFamilies) { ERROR_OUT(("Failed to alloc FHFAMILIES")); DC_QUIT; }
SET_STAMP(lpFamilies, FHFAMILIES);
hdcDesktop = GetWindowDC(HWND_DESKTOP);
//
// Find all the font family names.
//
lpFamilies->fhcFamilies = 0; EnumFontFamilies(hdcDesktop, NULL,(FONTENUMPROC)FHEachFontFamily, (LPARAM)lpFamilies);
TRACE_OUT(("Found %d font families ", lpFamilies->fhcFamilies));
//
// Now enumerate each font for each family
//
for (i = 0; i < lpFamilies->fhcFamilies; i++) { EnumFontFamilies(hdcDesktop, lpFamilies->afhFamilies[i].szFontName, (FONTENUMPROC)FHEachFont, (LPARAM)hdcDesktop); }
ReleaseDC(HWND_DESKTOP, hdcDesktop);
DC_EXIT_POINT: //
// Having considered all the fonts, we can now free the list of family
// names.
//
if (lpFamilies) { delete lpFamilies; }
DebugExitVOID(FHConsiderAllLocalFonts);}
//
// FHGenerateFontWidthTable
//
BOOL FHGenerateFontWidthTable(PFHWIDTHTABLE pTable, LPLOCALFONT pFontInfo, UINT fontHeight, UINT fontWidth, UINT fontWeight, UINT fontFlags, LPTSHR_UINT16 pMaxAscent)
{ HFONT hNewFont; HFONT hOldFont; BOOL gdiRC; UINT i; HDC cachedDC; BOOL localRC; BOOL functionRC; TEXTMETRIC textmetrics; int width; UINT aFontSizes[256];
DebugEntry(FHGenerateFontWidthTable);
//
// Set the return value to FALSE (unsuccessful). We will set it to
// TRUE later if the function succeeds.
//
functionRC = FALSE;
//
// Set the old font handle to NULL. If this is not NULL at the exit
// point of this function then we will select it back into the cachedDC
// device context.
//
hOldFont = NULL;
//
// Set the new font handle to NULL. If this is not NULL at the exit
// point of this function then the new font will be deleted.
//
hNewFont = NULL;
//
// Get a cached DC with which to do the query.
//
cachedDC = GetDC(HWND_DESKTOP); if (cachedDC == NULL) { WARNING_OUT(( "Failed to get DC")); DC_QUIT; }
//
// Get all the info we need from the local font table.
//
localRC = FH_CreateAndSelectFont(cachedDC, &hNewFont, &hOldFont, pFontInfo->RealName, pFontInfo->Details.nfCodePage, pFontInfo->lMaxBaselineExt, fontHeight, fontWidth, fontWeight, fontFlags);
if (localRC == FALSE) { ERROR_OUT(( "Failed to create/select font %s, %u, %u", pFontInfo->RealName, fontHeight, fontWidth)); DC_QUIT; }
//
// Determine if the current font is a truetype font.
//
GetTextMetrics(cachedDC, &textmetrics);
if (textmetrics.tmPitchAndFamily & TMPF_TRUETYPE) { //
// Truetype fonts are ABC spaced.
//
ABC abc[256];
TRACE_OUT(("TrueType font %s, first char %d last char %d", pFontInfo->RealName, (UINT)(WORD)textmetrics.tmFirstChar, (UINT)(WORD)textmetrics.tmLastChar));
//
// Get all widths in one call - faster than getting them separately
//
GetCharABCWidths(cachedDC, 0, 255, abc);
for (i = 0; i < 256; i++) { width = abc[i].abcA + abc[i].abcB + abc[i].abcC;
if ((width < 0) || (width > 255)) { //
// Width is outside the range we can cope with, so quit.
//
TRACE_OUT(( "Width %d is outside range", width)); DC_QUIT; } pTable->charWidths[i] = (BYTE)width; }
} else { TRACE_OUT(( "Non-truetype font"));
//
// Check if the font is fixed or variable pitch - note that a clear
// bit indicates FIXED, not the reverse which you might expect!
//
if ((textmetrics.tmPitchAndFamily & TMPF_FIXED_PITCH) == 0) { //
// No need to call GetCharWidth for a fixed width font (and
// more to the point it can return us bad values if we do)
//
for (i = 0; i < 256; i++) { aFontSizes[i] = textmetrics.tmAveCharWidth; } } else { //
// Query the width of each character in the font.
//
ZeroMemory(aFontSizes, sizeof(aFontSizes)); gdiRC = GetCharWidth(cachedDC, 0, 255, (LPINT)aFontSizes); if (gdiRC == FALSE) { ERROR_OUT(( "Failed to get char widths for %s, %u, %u", pFontInfo->RealName, fontHeight, fontWidth)); DC_QUIT; } }
//
// Now copy the widths into the width table.
// We must adjust the widths to take account of any overhang
// between characters.
//
for (i = 0; i < 256; i++) { width = aFontSizes[i] - textmetrics.tmOverhang; if ((width < 0) || (width > 255)) { TRACE_OUT(( "Width %d is outside range", width)); DC_QUIT; } pTable->charWidths[i] = (BYTE)width; } }
//
// The font table has been successfully generated.
//
functionRC = TRUE;
TRACE_OUT(( "Generated font table for: %s", pFontInfo->RealName));
//
// Return the maxAscent value, as we have easy access to it here. This
// saves us having to create the font again later to find it.
//
TRACE_OUT(( "Updating maxAscent %hu -> %hu", *pMaxAscent, (TSHR_UINT16)textmetrics.tmAscent)); *pMaxAscent = (TSHR_UINT16)textmetrics.tmAscent;
DC_EXIT_POINT:
if (hOldFont != NULL) { SelectFont(cachedDC, hOldFont); }
if (hNewFont != NULL) { DeleteFont(hNewFont); }
if (cachedDC != NULL) { ReleaseDC(HWND_DESKTOP, cachedDC); }
DebugExitDWORD(FHGenerateFontWidthTable, functionRC); return(functionRC);}
//
// Define a macro to simplify the following code. This returns the first
// character in the name of the font at position i in the local table.
//
//
// nfFaceName is an array of CHARs, which are SIGNED. We need to treat them
// as UNSIGNED values, they are indeces from 0 to 255 into the font hash
// table.
//
#define LF_FIRSTCHAR(i) (BYTE)g_fhFonts->afhFonts[i].Details.nfFaceName[0]
//
// Name: FHSortAndIndexLocalFonts
//
// Purpose: Sorts local font table by font name and generates an index for
// quicker searching in the display driver.
//
// Returns: None.
//
// Params: None.
//
//
void FHSortAndIndexLocalFonts(void){ TSHR_UINT16 thisIndexEntry; TSHR_UINT16 fontTablePos;
DebugEntry(FHSortAndIndexLocalFonts);
//
// Check there are actually some fonts to sort/index
//
if (0 == g_fhFonts->fhNumFonts) { WARNING_OUT(( "No fonts to sort/index")); DC_QUIT; }
//
// Use qsort to do the sort. We sort on the font name, ascending.
// Therefore we must use STRCMP and not lstrcmp. The latter sorts
// by 'word' method, where upper case sorts before lower case. But
// our NT driver has no access to a similar routine. And this code +
// driver code must be in ssync for the driver to successfully search
// the sorted font table.
//
FH_qsort(g_fhFonts->afhFonts, g_fhFonts->fhNumFonts, sizeof(LOCALFONT)); TRACE_OUT(( "Sorted local font list"));
//
// Now generate the index. Each element i in the g_fhFonts->afhFontIndex
// array must indicate the first entry in the local font table
// beginning with character i. If there are no fonts beginning with
// character i, then the element is set to USHRT_MAX (i.e. a large
// value).
//
//
// First clear the index table to unused entries.
//
for (thisIndexEntry = 0; thisIndexEntry < FH_LOCAL_INDEX_SIZE; thisIndexEntry++) { g_fhFonts->afhFontIndex[thisIndexEntry] = USHRT_MAX; }
//
// Now fill in the useful information.
//
// This for loop steps through the index array, using the first
// character of the first font in the local table as its start point.
// Since the font table is alphabetically sorted, this will correspond
// to the first index entry that needs filling in.
//
// The terminating condition for this loop may seem a little odd, but
// works because fontTablePos will always reach a value of g_fhFonts->fhNumFonts
// before thisIndexEntry gets to the last index element.
//
fontTablePos = 0;
for (thisIndexEntry = LF_FIRSTCHAR(0); fontTablePos < g_fhFonts->fhNumFonts; thisIndexEntry++) { //
// Don't do anything until we get to the index element
// corresponding to the first character in the font pointed to by
// fontTablePos. (We'll be there straight away on the first pass)
//
if (thisIndexEntry == LF_FIRSTCHAR(fontTablePos)) { //
// We've found the first font table entry starting with
// character thisIndexEntry, so enter it in the index.
//
g_fhFonts->afhFontIndex[thisIndexEntry] = fontTablePos;
//
// Now zip past the rest of the local font table entries that
// start with this character, also checking that we haven't got
// to the end of the font table.
//
// If the latter happens, it means we've finished and the check
// in the for statement will ensure that we exit the loop.
//
while ((LF_FIRSTCHAR(fontTablePos) == thisIndexEntry) && (fontTablePos < g_fhFonts->fhNumFonts)) { fontTablePos++; } } }
TRACE_OUT(( "Built local font table index"));
DC_EXIT_POINT: DebugExitVOID(FHSortAndIndexLocalFonts);}
//
// FHComp()
// This is a wrapper around strcmp(), which becomes an inline function in
// retail. It also handles the casting of the LPVOIDs.
//
//
// Compare item 1, item 2
//
int FHComp( LPVOID lpFont1, LPVOID lpFont2){ return(strcmp(((LPLOCALFONT)lpFont1)->Details.nfFaceName, ((LPLOCALFONT)lpFont2)->Details.nfFaceName));}
//
// FH_qsort(base, num, wid) - quicksort function for sorting arrays
//
// Purpose:
// quicksort the array of elements
// side effects: sorts in place
//
// Entry:
// char *base = pointer to base of array
// unsigned num = number of elements in the array
// unsigned width = width in bytes of each array element
//
// Exit:
// returns void
//
// Exceptions:
//
// sort the array between lo and hi (inclusive)
void FH_qsort( LPVOID base, UINT num, UINT width){ LPSTR lo; LPSTR hi; LPSTR mid; LPSTR loguy; LPSTR higuy; UINT size; char *lostk[30], *histk[30]; int stkptr; // stack for saving sub-array to be processed
// Note: the number of stack entries required is no more than
// 1 + log2(size), so 30 is sufficient for any array
ASSERT(width); if (num < 2) return; // nothing to do
stkptr = 0; // initialize stack
lo = (LPSTR)base; hi = (LPSTR)base + width * (num-1); // initialize limits
// this entry point is for pseudo-recursion calling: setting
// lo and hi and jumping to here is like recursion, but stkptr is
// prserved, locals aren't, so we preserve stuff on the stack
recurse:
size = (UINT)(hi - lo) / width + 1; // number of el's to sort
// below a certain size, it is faster to use a O(n^2) sorting method
if (size <= CUTOFF) { shortsort(lo, hi, width); } else { // First we pick a partititioning element. The efficiency of the
// algorithm demands that we find one that is approximately the
// median of the values, but also that we select one fast. Using
// the first one produces bad performace if the array is already
// sorted, so we use the middle one, which would require a very
// weirdly arranged array for worst case performance. Testing shows
// that a median-of-three algorithm does not, in general, increase
// performance.
mid = lo + (size / 2) * width; // find middle element
swap(mid, lo, width); // swap it to beginning of array
// We now wish to partition the array into three pieces, one
// consisiting of elements <= partition element, one of elements
// equal to the parition element, and one of element >= to it. This
// is done below; comments indicate conditions established at every
// step.
loguy = lo; higuy = hi + width;
// Note that higuy decreases and loguy increases on every iteration,
// so loop must terminate.
for (;;) { // lo <= loguy < hi, lo < higuy <= hi + 1,
// A[i] <= A[lo] for lo <= i <= loguy,
// A[i] >= A[lo] for higuy <= i <= hi
do { loguy += width; } while ((loguy <= hi) && (FHComp(loguy, lo) <= 0));
// lo < loguy <= hi+1, A[i] <= A[lo] for lo <= i < loguy,
// either loguy > hi or A[loguy] > A[lo]
do { higuy -= width; } while ((higuy > lo) && (FHComp(higuy, lo) >= 0));
// lo-1 <= higuy <= hi, A[i] >= A[lo] for higuy < i <= hi,
// either higuy <= lo or A[higuy] < A[lo]
if (higuy < loguy) break;
// if loguy > hi or higuy <= lo, then we would have exited, so
// A[loguy] > A[lo], A[higuy] < A[lo],
// loguy < hi, highy > lo
swap(loguy, higuy, width);
// A[loguy] < A[lo], A[higuy] > A[lo]; so condition at top
// of loop is re-established
}
// A[i] >= A[lo] for higuy < i <= hi,
// A[i] <= A[lo] for lo <= i < loguy,
// higuy < loguy, lo <= higuy <= hi
// implying:
// A[i] >= A[lo] for loguy <= i <= hi,
// A[i] <= A[lo] for lo <= i <= higuy,
// A[i] = A[lo] for higuy < i < loguy
swap(lo, higuy, width); // put partition element in place
// OK, now we have the following:
// A[i] >= A[higuy] for loguy <= i <= hi,
// A[i] <= A[higuy] for lo <= i < higuy
// A[i] = A[lo] for higuy <= i < loguy
// We've finished the partition, now we want to sort the subarrays
// [lo, higuy-1] and [loguy, hi].
// We do the smaller one first to minimize stack usage.
// We only sort arrays of length 2 or more.
if ( higuy - 1 - lo >= hi - loguy ) { if (lo + width < higuy) { lostk[stkptr] = lo; histk[stkptr] = higuy - width; ++stkptr; } // save big recursion for later
if (loguy < hi) { lo = loguy; goto recurse; // do small recursion
} } else { if (loguy < hi) { lostk[stkptr] = loguy; histk[stkptr] = hi; ++stkptr; // save big recursion for later
}
if (lo + width < higuy) { hi = higuy - width; goto recurse; // do small recursion
} } }
// We have sorted the array, except for any pending sorts on the stack.
// Check if there are any, and do them.
--stkptr; if (stkptr >= 0) { lo = lostk[stkptr]; hi = histk[stkptr]; goto recurse; // pop subarray from stack
} else return; // all subarrays done
}
//
// shortsort(hi, lo, width) - insertion sort for sorting short arrays
//
// Purpose:
// sorts the sub-array of elements between lo and hi (inclusive)
// side effects: sorts in place
// assumes that lo < hi
//
// Entry:
// char *lo = pointer to low element to sort
// char *hi = pointer to high element to sort
// unsigned width = width in bytes of each array element
//
// Exit:
// returns void
//
// Exceptions:
//
void shortsort( char *lo, char *hi, unsigned int width){ char *p, *max;
// Note: in assertions below, i and j are alway inside original bound of
// array to sort.
while (hi > lo) { // A[i] <= A[j] for i <= j, j > hi
max = lo; for (p = lo+width; p <= hi; p += width) { // A[i] <= A[max] for lo <= i < p
if (FHComp(p, max) > 0) { max = p; } // A[i] <= A[max] for lo <= i <= p
}
// A[i] <= A[max] for lo <= i <= hi
swap(max, hi, width);
// A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi
hi -= width;
// A[i] <= A[j] for i <= j, j > hi, loop top condition established
} // A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j,
// so array is sorted
}
//
// swap(a, b, width) - swap two elements
//
// Purpose:
// swaps the two array elements of size width
//
// Entry:
// char *a, *b = pointer to two elements to swap
// unsigned width = width in bytes of each array element
//
// Exit:
// returns void
//
// Exceptions:
//
void swap ( char *a, char *b, unsigned int width ){ char tmp;
if ( a != b ) // Do the swap one character at a time to avoid potential alignment
// problems.
while ( width-- ) { tmp = *a; *a++ = *b; *b++ = tmp; }}
|
