archive
/
windows-nt-4.0
mirror of https://github.com/lianthony/NT4.0
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Windows NT 4.0 source code leak
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
0 Tags
184 MiB
 
 
 
 
 
 
Tree: b4a8d373d8
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b4a8d373d8'
${ noResults }
windows-nt-4.0/private/ntos/w32/ntgdi/fondrv/tt/ttfd/vertical.c

987 lines
29 KiB
Raw Blame History

/******************************Module*Header*******************************\
* Module Name: vertical.c *
* *
* vertical writing (@face) support functions *
* whole file should be #ifdef-ed with DBCS_VERT *
* *
* Created: 18-Mar-1993 11:55:38 *
* Author: Takao Kitano [TakaoK] *
* *
* Copyright (c) 1993 Microsoft Corporation *
\**************************************************************************/
#include "fd.h"
//#include "fontfile.h"
//#include "cvt.h"
//#include "limits.h"
//#include "winnls.h"
#ifdef DBCS_VERT_DEBUG
ULONG DebugVertical = 0;
#endif
//
// Glyph Metamorphosis table (mort) structures
//
typedef struct {
uint16 entrySize; // size in bytes of a lookup entry ( should be 4 )
uint16 nEntries; // number of lookup entries to be searched
uint16 searchRange;
uint16 entrySelector;
uint16 rangeShift;
} BinSrchHeader;
typedef struct {
uint16 glyphid1; // the glyph index for the horizontal shape
uint16 glyphid2; // the glyph index for the vertical shape
} LookupSingle;
typedef struct {
BYTE constants1[12];
uint32 length1;
BYTE onstants2[16];
BYTE constants3[16];
BYTE constants4[8];
uint16 length2;
BYTE constants5[8];
BinSrchHeader SearchHeader;
LookupSingle entries[1];
} MortTable;
//
// Glyph Substitution table (GSUB) structures
//
#pragma pack(1)
typedef uint16 Offset;
typedef uint16 GlyphID;
typedef ULONG Tag;
typedef struct {
GlyphID Start;
GlyphID End;
uint16 StartCoverageIndex;
} RangeRecord;
typedef struct {
uint16 CoverageFormat;
union {
struct {
uint16 GlyphCount;
GlyphID GlyphArray[1];
} Type1;
struct {
uint16 RangeCount;
RangeRecord RangeRecord[1];
} Type2;
} Format;
} Coverage;
typedef struct {
uint16 SubstFormat;
union {
struct {
Offset Coverage;
uint16 DeltaGlyphID;
} Type1;
struct {
Offset Coverage;
uint16 GlyphCount;
GlyphID Substitute[1];
} Type2;
} Format;
} SingleSubst;
typedef struct {
uint32 Version;
Offset ScriptListOffset;
Offset FeatureListOffset;
Offset LookupListOffset[];
} GsubTable;
typedef struct {
uint16 LookupType;
uint16 LookupFlag;
uint16 SubtableCount;
Offset Subtable[1];
} Lookup;
typedef struct {
uint16 LookupCount;
Lookup Lookup[1];
} LookupList;
typedef struct {
Offset FeatureParams;
uint16 LookupCount;
uint16 LookupListIndex[1];
} Feature;
typedef struct {
Tag FeatureTag;
Offset FeatureOffset;
} FeatureRecord;
typedef struct {
uint16 FeatureCount;
FeatureRecord FeatureRecord[1];
} FeatureList;
typedef struct {
Offset LookupOrderOffset;
uint16 ReqFeatureIndex;
uint16 FeatureCount;
uint16 FeatureIndex[1];
} LangSys;
typedef struct {
Tag LangSysTag;
Offset LangSysOffset;
} LangSysRecord;
typedef struct {
Offset DefaultLangSysOffset;
uint16 LangSysCount;
LangSysRecord LangSysRecord[1];
} Script;
typedef struct {
Tag ScriptTag;
Offset ScriptOffset;
} ScriptRecord;
typedef struct {
uint16 ScriptCount;
ScriptRecord ScriptRecord[1];
} ScriptList;
#pragma pack()
/******************************Public*Routine******************************\
*
* bCheckVerticalTable()
*
* History:
* 12-Apr-1995 -by- Hideyuki Nagase [HideyukN]
* Wrote it.
\**************************************************************************/
BOOL bCheckVerticalTable(
PFONTFILE pff
)
{
//
// Is mort table present ?
//
if( pff->tp.ateOpt[ IT_OPT_MORT ].cj != 0 &&
pff->tp.ateOpt[ IT_OPT_MORT ].dp != 0 )
{
pff->ulVerticalTableOffset = pff->tp.ateOpt[ IT_OPT_MORT ].dp;
pff->hgSearchVerticalGlyph = SearchMortTable;
return(TRUE);
}
//
// Is GSUB table present ?
//
else if( pff->tp.ateOpt[ IT_OPT_GSUB ].cj != 0 &&
pff->tp.ateOpt[ IT_OPT_GSUB ].dp != 0 )
{
//
// Check this GSUB table is for Vertical Glyphs ?
//
GsubTable *pGsubTable;
ScriptList *pScriptList;
FeatureList *pFeatureList;
LookupList *pLookupList;
ULONG dpGsubTable;
ULONG dpScriptList;
ULONG dpFeatureList;
ULONG dpLookupList;
INT ii;
USHORT LookupIndex;
ULONG VerticalLookupOffset = 0;
ULONG VerticalFeatureOffset = 0;
ULONG VerticalSubtableOffset = 0;
Feature *pFeature;
Lookup *pLookup;
dpGsubTable = pff->tp.ateOpt[ IT_OPT_GSUB ].dp;
pGsubTable = (GsubTable *)((BYTE *)(pff->pvView) + dpGsubTable);
dpScriptList = BE_UINT16(&pGsubTable->ScriptListOffset);
dpFeatureList = BE_UINT16(&pGsubTable->FeatureListOffset);
dpLookupList = BE_UINT16(&pGsubTable->LookupListOffset);
pScriptList = (ScriptList *)((BYTE *)pGsubTable + dpScriptList);
pFeatureList = (FeatureList *)((BYTE *)pGsubTable + dpFeatureList);
pLookupList = (LookupList *)((BYTE *)pGsubTable + dpLookupList);
#if DBG_MORE
TtfdDbgPrint("TTFD!GsubTable - %x\n",pGsubTable);
TtfdDbgPrint("TTFD!ScriptList - %x\n",pScriptList);
TtfdDbgPrint("TTFD!FeatureList - %x\n",pFeatureList);
TtfdDbgPrint("TTFD!LookupList - %x\n",pLookupList);
#endif
//
// Search 'vert' Tag from FeatureList....
//
#define tag_vert 0x74726576
for( ii = 0;
ii < BE_INT16(&pFeatureList->FeatureCount) ;
ii++ )
{
if( pFeatureList->FeatureRecord[ii].FeatureTag == tag_vert )
{
VerticalFeatureOffset = BE_UINT16(
&(pFeatureList->FeatureRecord[ii].FeatureOffset)
);
#if DBG_MORE
TtfdDbgPrint("TTFD:VerticalFeature - %x\n",VerticalFeatureOffset);
#endif
break;
}
}
//
// if we could not find out 'vert' tag, this is a not vertical font.
//
if( VerticalFeatureOffset == 0 )
{
WARNING("TTFD!Could not find 'vert' tag in FeatureList\n");
return(FALSE);
}
//
// Vertical feature offset contains offset from FeatureList...
// adjust it to offset from GsubTable..
//
VerticalFeatureOffset += dpFeatureList;
//
// Compute pointer to Feature offset.
//
pFeature = (Feature *)((BYTE *)pGsubTable + VerticalFeatureOffset);
//
// for Vertical glyph substitution, the lookup count should be 1.
//
if( BE_UINT16(&pFeature->LookupCount) != 1 )
{
WARNING("pFeature->LookupCount != 1\n");
return(FALSE);
}
//
// make sure the Lookup list has a entry for this feature....
//
LookupIndex = BE_UINT16(&(pFeature->LookupListIndex[0]));
if( BE_UINT16(&pLookupList->LookupCount) < LookupIndex )
{
WARNING("LookupIndex < LookupCount\n");
return(FALSE);
}
//
// Compute pointer to Lookup..
//
VerticalLookupOffset = BE_UINT16(&(pLookupList->Lookup[LookupIndex]));
pLookup = (Lookup *)((BYTE *)pLookupList + VerticalLookupOffset);
#if DBG_MORE
TtfdDbgPrint("pLookup - %x\n",pLookup);
#endif
//
// Check Lookup Type, it should be 1 (='Single') for vertical font.
//
if( BE_UINT16(&pLookup->LookupType) != 1 )
{
WARNING("LookupType != 1\n");
return(FALSE);
}
//
// Check subtable count.. it should be 1 for vertical font.
//
if( BE_UINT16(&pLookup->SubtableCount) != 1 )
{
WARNING("SubTableCount != 1\n");
return(FALSE);
}
//
// Compute offset to subtable from FileTop...
//
VerticalSubtableOffset = BE_UINT16(&(pLookup->Subtable[0]));
VerticalSubtableOffset += VerticalLookupOffset;
VerticalSubtableOffset += dpLookupList;
VerticalSubtableOffset += dpGsubTable;
#if DBG_MORE
TtfdDbgPrint("Subtable Offset - %x\n",VerticalSubtableOffset);
#endif
pff->ulVerticalTableOffset = VerticalSubtableOffset;
pff->hgSearchVerticalGlyph = SearchGsubTable;
return(TRUE);
}
else
{
//
// Set dummy..
//
pff->ulVerticalTableOffset = 0;
pff->hgSearchVerticalGlyph = SearchDummyTable;
}
return(TRUE);
}
/******************************Public*Routine******************************\
*
* SearchDummyTable()
*
* History:
* 14-Jan-1996 -by- Hideyuki Nagase [HideyukN]
* Wrote it.
\**************************************************************************/
ULONG SearchDummyTable(
FONTCONTEXT *pfc,
ULONG ig // glyph index
)
{
return ig;
}
/******************************Public*Routine******************************\
*
* SearhVerticalGlyphIndex( FONTCONTEXT *pfc, ULONG ig )
*
* If there is glyph index for the vertical shape, returns
* the glyph index of vertical shape, else returns same
* glyph index as specified.
*
* History:
* 04-Apr-1993 -by- Takao Kitano [TakaoK]
* Wrote it.
\**************************************************************************/
ULONG SearchMortTable(
FONTCONTEXT *pfc,
ULONG ig // glyph index
)
{
MortTable *pMortTable;
BinSrchHeader *pHeader;
LookupSingle *pLookup;
USHORT n;
pMortTable = (MortTable *)((BYTE *)(pfc->pff->pvView) +
(pfc->pff->ulVerticalTableOffset));
#if DBG
if ( pMortTable == NULL )
{
WARNING("pMortTable == NULL\n");
return ig;
}
#endif
pHeader = &pMortTable->SearchHeader;
//
// If you have time, you may want to change the loop from the straight search
// to the binary search. Currently kanji truetype font has about 110 entries
// for alternative glyphs. [takaok]
//
for ( pLookup = &pMortTable->entries[0], n = BE_UINT16(&pHeader->nEntries);
n > 0;
n--, pLookup++
)
{
if ( ig == (ULONG)BE_UINT16( &pLookup->glyphid1 ) )
return ( BE_UINT16( &pLookup->glyphid2 ) );
}
return ( ig );
}
/******************************Public*Routine******************************\
*
* SearchGsubTable()
*
* History:
* 12-Apr-1995 -by- Hideyuki Nagase [HideyukN]
* Wrote it.
\**************************************************************************/
ULONG SearchGsubTable(
FONTCONTEXT *pfc,
ULONG ig // glyph index
)
{
SingleSubst *pSingleSubst;
pSingleSubst = (SingleSubst *)((BYTE *)(pfc->pff->pvView) +
(pfc->pff->ulVerticalTableOffset));
//
// Check subtable format...
//
if( BE_UINT16(&pSingleSubst->SubstFormat) == 2 )
{
Coverage *pCoverage;
pCoverage = (Coverage *)
((BYTE *)pSingleSubst +
BE_UINT16(&(pSingleSubst->Format.Type2.Coverage)));
//
// Check Coverage format...
//
if( BE_UINT16(&pCoverage->CoverageFormat) == 1 )
{
USHORT ii;
GlyphID *pGlyphArray;
GlyphID *pGlyphSubstArray;
pGlyphArray = pCoverage->Format.Type1.GlyphArray;
pGlyphSubstArray = pSingleSubst->Format.Type2.Substitute;
for( ii = 0;
ii < BE_UINT16(&(pCoverage->Format.Type1.GlyphCount)) ;
ii ++ )
{
if( ig == (ULONG)BE_UINT16(&(pGlyphArray[ii])) )
return( (ULONG)BE_UINT16(&(pGlyphSubstArray[ii])) );
}
}
else
{
WARNING("TTFD:Unsupported CoverageFormat\n");
}
}
else
{
WARNING("TTFD:Unsupported SubstFormat\n");
}
return(ig);
}
/******************************Public*Routine******************************\
*
* vCalcXformVertical
*
* Right now, we assume all the width of glyphs that need to be rotated
* for @face are same. ( I mean all kanji character has same width. )
* So a single transformation is applied to all rotated glyphs.
*
* Before the final release, we need to change this scheme. We will
* check the advanceWidth in notional space ( please refer to
* vGetNotionalGlyphMetrics ). If the advanceWidth of specified
* glyph is different than the maxCharInc, we will compute the
* transformation matrix dynamically. [takaok]
*
* History:
* 19-Mar-1993 -by- Takao Kitano [TakaoK]
* Wrote it.
\**************************************************************************/
VOID vCalcXformVertical ( FONTCONTEXT *pfc )
{
LONG lWidth, lHeight, lAscender, lDescender;
lWidth = (LONG)pfc->pff->ifi.fwdMaxCharInc;
lAscender = (LONG)pfc->pff->ifi.fwdWinAscender;
lDescender = (LONG)pfc->pff->ifi.fwdWinDescender;
lHeight = lAscender + lDescender;
#ifdef DBCS_VERT_DEBUG
if ( DebugVertical & DEBUG_VERTICAL_CALL )
{
TtfdDbgPrint("TTFD!bGetNotionalHeightAndWidth( Width=%ld, Ascent=%ld, Descent=%ld )\n",
lWidth, lAscender, lDescender);
}
#endif
//
// [ 90 degree rotation ]
//
// In the truetype rasterizer, 90 degree rotation matrix looks like this:
//
// A
// Y| [ cos90 sin90 ] [ 0 1 ]
// | [ ] = [ ]
// | X [ -sin90 cos90 ] [ -1 0 ]
// +------->
//
// [ X-Y scaling ]
//
// We don't want to change the character box shape after the rotation.
//
// [ h/w 0 ] where w: notional space width = IFIMETRICS.aveCharWidth
// [ ]
// [ 0 w/h ] h: notional space height = IFIMETRICS.Ascender +
// IFIMETRICS.Descender
//
// We are multiplying the scaling matrix from the left because the
// scaling matrix acts first on the notinal space vectors on the left
//
// ((x,y)*A)*B = (x,y)*(A*B)
//
// [ h/w 0 ] [ 0 1 ] [ 0 h/w ]
// [ ] * [ ] = [ ]
// [ 0 w/h ] [ -1 0 ] [ -w/h 0 ] ... this is it! [rotation] * [scaling] matrix
//
// We are multiplying from the left because the [ scaling * rotation ] matrix
// acts first on the notional space vectors on the left
//
// [ 0 h/w ] [ m00 m01 ] [ m10 * h / w m11 * h / w ]
// [ ] * [ ] = [ ]
// [-w/h 0 ] [ m10 m11 ] [ -m00 * w / h -m01 * w / h ]
if ( lHeight == lWidth )
{
pfc->mxv.transform[0][0] = pfc->mxn.transform[1][0];
pfc->mxv.transform[0][1] = pfc->mxn.transform[1][1];
pfc->mxv.transform[1][0] = -pfc->mxn.transform[0][0];
pfc->mxv.transform[1][1] = -pfc->mxn.transform[0][1];
}
else
{
pfc->mxv.transform[0][0] = LongMulDiv( pfc->mxn.transform[1][0], lHeight, lWidth);
pfc->mxv.transform[0][1] = LongMulDiv( pfc->mxn.transform[1][1], lHeight, lWidth);
pfc->mxv.transform[1][0] = LongMulDiv( pfc->mxn.transform[0][0], -lWidth, lHeight);
pfc->mxv.transform[1][1] = LongMulDiv( pfc->mxn.transform[0][1], -lWidth, lHeight);
}
pfc->mxv.transform[2][2] = ONEFIX;
pfc->mxv.transform[0][2] = (Fixed)0;
pfc->mxv.transform[1][2] = (Fixed)0;
pfc->mxv.transform[2][0] = (Fixed)0;
pfc->mxv.transform[2][1] = (Fixed)0;
//
// compute shift parameters in device space
// coordinate system is truetype coordinate.
//
// At early stage of development, I put the following shift
// information into the matrix passed to the scaler.
// However I don't know why but the scaler just ignores
// the X and Y shift values. In windows 3.1J, they
// changes the scaler interface ( fs_xxx ) and give the scaler
// X and Y shift information. For NT-J, I don't want to change
// the scaler interface. Following shift values are applied
// after we got bitmap information from scaler. [takaok]
//
{
Fixed lX;
Fixed lY;
//
// shift value in notional space
//
lX = LTOF16_16( lWidth - LongMulDiv(lDescender, lWidth, lHeight) );
lY = LTOF16_16( - lDescender );
//
// shift value in device space
//
pfc->fxdevShiftX = FixMul(pfc->mx.transform[0][0], lX) +
FixMul(pfc->mx.transform[1][0], lY);
pfc->fxdevShiftY = FixMul(pfc->mx.transform[0][1], lX) +
FixMul(pfc->mx.transform[1][1], lY);
}
#ifdef DBCS_VERT_DEBUG
if ( DebugVertical & DEBUG_VERTICAL_XFORM )
{
TtfdDbgPrint("vCalcXformVertical pfc->mx00 =0x%lx, 11=0x%lx, 01=0x%lx, 10=0x%lx \n",
pfc->mx.transform[0][0],
pfc->mx.transform[1][1],
pfc->mx.transform[0][1],
pfc->mx.transform[1][0] );
TtfdDbgPrint("vCalcXformVertical mxn:00=0x%lx, 11=0x%lx, 01=0x%lx, 10=0x%lx \n",
pfc->mxn.transform[0][0],
pfc->mxn.transform[1][1],
pfc->mxn.transform[0][1],
pfc->mxn.transform[1][0] );
TtfdDbgPrint(" mxv:00=0x%lx, 11=0x%lx, 01=0x%lx, 10=0x%lx \n",
pfc->mxv.transform[0][0],
pfc->mxv.transform[1][1],
pfc->mxv.transform[0][1],
pfc->mxv.transform[1][0] );
TtfdDbgPrint(" devShiftX=%ld, devShiftY=%ld \n",
F16_16TOLROUND(pfc->fxdevShiftX),F16_16TOLROUND(pfc->fxdevShiftY));
}
#endif
}
/******************************Public*Routine******************************\
*
* BOOL IsFullWidth( WCHAR wc)
*
* Returns TRUE if specified unicode codepoint is corresponding to
* double byte character in multibyte codepage.
*
* History:
* 10-Nov-1995 Hideyuki Nagase [hideyukn]
* Wrote it.
\**************************************************************************/
typedef struct _VERTICAL_UNICODE {
WCHAR Start;
WCHAR End;
} VERTICAL_UNICODE, *PVERTICAL_UNICODE;
#define NUM_VERTICAL_UNICODES 4
VERTICAL_UNICODE VerticalUnicodes[] = {
{ 0x4E00, 0x9FFF }, // CJK_UNIFIED_IDOGRAPHS
{ 0x3040, 0x309F }, // HIRAGANA
{ 0x30A0, 0x30FF }, // KATAKANA
{ 0xAC00, 0xD7A3 } // HANGUL
};
BOOL IsFullWidthCharacter( UINT FontCodePage, WCHAR wc )
{
int cwc;
char ach[2];
int index;
for (index = 0; index < NUM_VERTICAL_UNICODES; index++)
{
if ((wc >= VerticalUnicodes[index].Start) &&
(wc <= VerticalUnicodes[index].End) )
{
return (TRUE);
}
}
//
// if this Unicode character is mapped to Double-Byte character,
// this is also full-width character..
//
cwc = EngWideCharToMultiByte(FontCodePage,&wc,sizeof(WCHAR),ach,2);
return( cwc > 1 ? TRUE : FALSE );
}
/******************************Public*Routine******************************\
*
* BOOL bChangeXform( PFONTCONTEXT pfc, BOOL bRotation )
*
*
* if bRotation is TRUE: call the scaler with rotated transform.
* FALSE: call the scaler with normal transform.
*
* History:
* 19-Mar-1993 -by- Takao Kitano [TakaoK]
* Wrote it.
\**************************************************************************/
BOOL bChangeXform( PFONTCONTEXT pfc, BOOL bRotation )
{
FS_ENTRY iRet;
#ifdef DBCS_VERT_DEBUG
if ( DebugVertical & DEBUG_VERTICAL_CALL )
{
TtfdDbgPrint("TTFD!bChangeXform:bRotation=%s\n", bRotation ? "TRUE":"FALSE");
}
#endif
vInitGlyphState(&pfc->gstat);
if ( bRotation )
{
pfc->pgin->param.newtrans.transformMatrix = &(pfc->mxv);
}
else
{
pfc->pgin->param.newtrans.transformMatrix = &(pfc->mxn);
}
pfc->pgin->param.newtrans.pointSize = pfc->pointSize;
pfc->pgin->param.newtrans.xResolution = (int16)pfc->sizLogResPpi.cx;
pfc->pgin->param.newtrans.yResolution = (int16)pfc->sizLogResPpi.cy;
pfc->pgin->param.newtrans.pixelDiameter = FIXEDSQRT2;
pfc->pgin->param.newtrans.traceFunc = (FntTraceFunc)NULL;
if ((iRet = fs_NewTransformation(pfc->pgin, pfc->pgout)) != NO_ERR)
{
V_FSERROR(iRet);
#if DBG
TtfdDbgPrint("bChangeXform(%-#x,%d) failed\n", pfc, bRotation);
#endif
return(FALSE);
}
return TRUE;
}
/******************************Public*Routine******************************\
*
* VOID vShiftBitmapInfo( FONTCONTEXT *pfc, fs_GlyphInfoType *pgout )
*
*
* Modifies following values.
*
* Using pfc->devShiftX and pfc->devShiftY:
*
* gout.bitMapInfo.bounds.right
* gout.bitMapInfo.bounds.left
* gout.bitMapInfo.bounds.top
* gout.bitMapInfo.bounds.bottom
* gout.metricInfo.devLeftSideBearing.x
* gout.metricInfo.devLeftSideBearing.y
*
* Using -90 degree rotation
*
* gout.metricInfo.devAdvanceWidth.x
* gout.metricInfo.devAdvanceWidth.y
*
* History:
* 04-Apr-1993 -by- Takao Kitano [TakaoK]
* Wrote it.
\**************************************************************************/
VOID vShiftBitmapInfo(
FONTCONTEXT *pfc,
fs_GlyphInfoType *pgoutDst,
fs_GlyphInfoType *pgoutSrc)
{
SHORT sdevShiftX = (SHORT) F16_16TOLROUND(pfc->fxdevShiftX);
SHORT sdevShiftY = (SHORT) F16_16TOLROUND(pfc->fxdevShiftY);
pgoutDst->bitMapInfo.bounds.right = pgoutSrc->bitMapInfo.bounds.right + sdevShiftX;
pgoutDst->bitMapInfo.bounds.left = pgoutSrc->bitMapInfo.bounds.left + sdevShiftX;
pgoutDst->bitMapInfo.bounds.top = pgoutSrc->bitMapInfo.bounds.top + sdevShiftY;
pgoutDst->bitMapInfo.bounds.bottom = pgoutSrc->bitMapInfo.bounds.bottom + sdevShiftY;
pgoutDst->metricInfo.devLeftSideBearing.x = pgoutSrc->metricInfo.devLeftSideBearing.x + pfc->fxdevShiftX;
pgoutDst->metricInfo.devLeftSideBearing.y = pgoutSrc->metricInfo.devLeftSideBearing.y + pfc->fxdevShiftY;
//
// -90degree rotation in truetype coordinate system
//
// [ 0 -1 ]
// (newX, newY) = ( x, y ) * [ ] = (y, -x )
// [ 1 0 ]
// A
// Y|
// |
// |
// +----->
// X
//
pgoutDst->metricInfo.devAdvanceWidth.x = pgoutSrc->metricInfo.devAdvanceWidth.y;
pgoutDst->metricInfo.devAdvanceWidth.y = - pgoutSrc->metricInfo.devAdvanceWidth.x;
#ifdef DBCS_VERT_DEBUG
if ( DebugVertical & DEBUG_VERTICAL_BITMAPINFO )
{
TtfdDbgPrint("=====TTFD:vShiftBitmapInfo() before \n");
TtfdDbgPrint("bitMapInfo.bounds:right=%ld, left=%ld, top=%ld, bottom=%ld\n",
pgoutSrc->bitMapInfo.bounds.right,
pgoutSrc->bitMapInfo.bounds.left,
pgoutSrc->bitMapInfo.bounds.top,
pgoutSrc->bitMapInfo.bounds.bottom);
TtfdDbgPrint("metricInfo.devLeftSideBearing x = %ld, y=%ld \n",
F16_16TOLROUND(pgoutSrc->metricInfo.devLeftSideBearing.x),
F16_16TOLROUND(pgoutSrc->metricInfo.devLeftSideBearing.y));
TtfdDbgPrint("metricInfo.devAdvanceWidth x = %ld, y=%ld \n",
F16_16TOLROUND(pgoutSrc->metricInfo.devAdvanceWidth.x),
F16_16TOLROUND(pgoutSrc->metricInfo.devAdvanceWidth.y));
TtfdDbgPrint("=====TTFD:vShiftBitmapInfo() after \n");
TtfdDbgPrint("bitMapInfo.bounds:right=%ld, left=%ld, top=%ld, bottom=%ld\n",
pgoutDst->bitMapInfo.bounds.right,
pgoutDst->bitMapInfo.bounds.left,
pgoutDst->bitMapInfo.bounds.top,
pgoutDst->bitMapInfo.bounds.bottom);
TtfdDbgPrint("metricInfo.devLeftSideBearing x = %ld, y=%ld \n",
F16_16TOLROUND(pgoutDst->metricInfo.devLeftSideBearing.x),
F16_16TOLROUND(pgoutDst->metricInfo.devLeftSideBearing.y));
TtfdDbgPrint("metricInfo.devAdvanceWidth x = %ld, y=%ld \n",
F16_16TOLROUND(pgoutDst->metricInfo.devAdvanceWidth.x),
F16_16TOLROUND(pgoutDst->metricInfo.devAdvanceWidth.y));
}
#endif
}
/******************************Public*Routine******************************\
*
* vShiftOutlineInfo()
*
* History:
* 04-Apr-1993 -by- Hideyuki Nagase [HideyukN]
* Wrote it.
\**************************************************************************/
#define CJ_CRV(pcrv) \
( \
offsetof(TTPOLYCURVE,apfx) + ((pcrv)->cpfx * sizeof(POINTFX)) \
)
VOID vAdd16FixTo16Fix(
FIXED *A ,
FIXED *B ,
BOOL bForceMinus
)
{
A->fract += B->fract;
A->value += B->value;
}
VOID vAdd16FixTo28Fix(
FIXED *A ,
FIXED *B ,
BOOL bForceMinus
)
{
Fixed longA , longB;
ASSERTDD( sizeof(FIXED) == sizeof(Fixed) , "TTFD:FIXED != ULONG\n" );
longA = *(Fixed *)A;
longB = *(Fixed *)B;
// !!! BUG BUG BUG !!!
//
// if outline request from PostScript printer driver, the driver
// can not get correct outline without following super hack.
// we most need feather investigation.
//
// propably, we should compute shift value accoring
// to device coordinate ???. Y axis is different
// between device and truetype coordinate.
// how about GetGlyphOutline() ???
// I just tested using gdi\test\fonttest.nt\fonttest.exe
// It seems work fine.
//
// start super-hack.
if(bForceMinus) longB = -longB;
// end super-hack.
longB = longB >> 12;
longA += longB;
*A = *(FIXED *)&longA;
}
VOID vShiftOutlineInfo(
FONTCONTEXT *pfc, // IN font context
BOOL b16Dot16, // IN Fixed format 16.16 or 28.4
BYTE *pBuffer, // OUT output buffer
ULONG cjTotal // IN buffer size
)
{
TTPOLYGONHEADER *ppoly, *ppolyStart, *ppolyEnd;
TTPOLYCURVE *pcrv, * pcrvEnd;
FIXED fxShiftX , fxShiftY;
ULONG cSpli , cSpliMax;
POINTFX *pptfix;
VOID (*vAddFunc)(FIXED *A,FIXED *B,BOOL bForceMinus);
BOOL bForceMinus;
*((Fixed *)&fxShiftX) = LTOF16_16( F16_16TOLROUND(pfc->fxdevShiftX) );
*((Fixed *)&fxShiftY) = LTOF16_16( F16_16TOLROUND(pfc->fxdevShiftY) );
if( b16Dot16 ) {
vAddFunc = vAdd16FixTo16Fix;
bForceMinus = FALSE;
} else {
vAddFunc = vAdd16FixTo28Fix;
bForceMinus = TRUE;
}
#ifdef DBCS_VERT_DEBUG
TtfdDbgPrint("====== START DUMP VERTICAL POLYGON ======\n");
TtfdDbgPrint("devShiftX=%ld, devShiftY=%ld \n"
,F16_16TOLROUND(*(Fixed *)&fxShiftX),
F16_16TOLROUND(*(Fixed *)&fxShiftY));
#endif // DBCS_VERT_DEBUG
ppolyStart = (TTPOLYGONHEADER *)pBuffer;
ppolyEnd = (TTPOLYGONHEADER *)(pBuffer + cjTotal);
for (
ppoly = ppolyStart;
ppoly < ppolyEnd;
ppoly = (TTPOLYGONHEADER *)((PBYTE)ppoly + ppoly->cb)
)
{
ASSERTDD(ppoly->dwType == TT_POLYGON_TYPE,"ppoly->dwType != TT_POLYGON_TYPE\n");
#ifdef DBCS_VERT_DEBUG
TtfdDbgPrint("ppoly->cb - %d\n",ppoly->cb);
#endif // DBCS_VERT_DEBUG
(*vAddFunc)( &ppoly->pfxStart.x , &fxShiftX , FALSE );
(*vAddFunc)( &ppoly->pfxStart.y , &fxShiftY , bForceMinus );
#ifdef DBCS_VERT_DEBUG
TtfdDbgPrint("StartPoint - ( %x , %x )\n",ppoly->pfxStart.x,ppoly->pfxStart.y);
#endif // DBCS_VERT_DEBUG
for (
pcrv = (TTPOLYCURVE *)(ppoly + 1),pcrvEnd = (TTPOLYCURVE *)((PBYTE)ppoly + ppoly->cb);
pcrv < pcrvEnd;
pcrv = (TTPOLYCURVE *)((PBYTE)pcrv + CJ_CRV(pcrv))
)
{
#ifdef DBCS_VERT_DEBUG
TtfdDbgPrint("Contents of TTPOLYCURVE (%d)\n",pcrv->cpfx);
#endif // DBCS_VERT_DEBUG
for (
cSpli = 0,cSpliMax = pcrv->cpfx,pptfix = &(pcrv->apfx[0]);
cSpli < cSpliMax;
cSpli ++,pptfix ++
)
{
(*vAddFunc)( &pptfix->x , &fxShiftX , FALSE );
(*vAddFunc)( &pptfix->y , &fxShiftY , bForceMinus );
#ifdef DBCS_VERT_DEBUG
TtfdDbgPrint(" - ( %x , %x )\n",pptfix->x,pptfix->y);
#endif // DBCS_VERT_DEBUG
}
}
#ifdef DBCS_VERT_DEBUG
TtfdDbgPrint("\n");
#endif // DBCS_VERT_DEBUG
}
#ifdef DBCS_VERT_DEBUG
TtfdDbgPrint("====== END DUMP VERTICAL POLYGON ======\n");
#endif // DBCS_VERT_DEBUG
}