Attachment #37342 for bug #59849

View | Details | Raw Unified | Return to bug 59849
Collapse All | Expand All




native FT_Sfnt_Tag(FT_Sfnt_Tag);
native FT_Size(FT_Size);

[ptr] native FTC_ImageType_p(FTC_ImageType);
native FTC_Face_Requester(FTC_Face_Requester);
native FTC_Font(FTC_Font);
native FTC_FaceID(FTC_FaceID);
native FTC_ImageCache(FTC_ImageCache);
native FTC_Manager(FTC_Manager);

// #ifdef MOZ_SVG


    readonly attribute FT_Library library;
    readonly attribute FTC_Manager FTCacheManager;
    readonly attribute FTC_ImageCache ImageCache;

    void    doneFace(in FT_Face face);
    void    doneFreeType(in FT_Library lib);

    void    outlineDecompose(in FT_Outline_p outline,
                             in const_FT_Outline_Funcs_p funcs, in voidPtr p);
    void    setCharmap(in FT_Face face, in FT_CharMap charmap);
    void    imageCacheLookup(in FTC_ImageCache cache, in FTC_ImageType_p desc,
                             in FT_UInt gindex, out FT_Glyph glyph);
    void    managerLookupFace(in FTC_Manager manager, in FTC_FaceID face_id,
                              out FT_Face face);
    void    managerDone(in FTC_Manager manager);
    void    managerNew(in FT_Library lib, in FT_UInt max_faces,
                       in FT_UInt max_sizes, in FT_ULong max_bytes,
                       in FTC_Face_Requester requester, in FT_Pointer req_data,
                       out FTC_Manager manager);
    void    imageCacheNew(in FTC_Manager manager, out FTC_ImageCache cache);
/* #ifdef MOZ_SVG */
    void glyphTransform(in FT_Glyph glyph, in FT_Matrix_p matrix,
                        in FT_Vector_p delta);




  {"FT_New_Face",             NS_FT2_OFFSET(nsFT_New_Face),             PR_TRUE},
  {"FT_Outline_Decompose",    NS_FT2_OFFSET(nsFT_Outline_Decompose),    PR_TRUE},
  {"FT_Set_Charmap",          NS_FT2_OFFSET(nsFT_Set_Charmap),          PR_TRUE},
  {"FTC_ImageCache_Lookup",   NS_FT2_OFFSET(nsFTC_Image_Cache_Lookup),  PR_TRUE},
  {"FTC_Manager_LookupFace",  NS_FT2_OFFSET(nsFTC_Manager_LookupFace),  PR_TRUE},
  {"FTC_Manager_Done",        NS_FT2_OFFSET(nsFTC_Manager_Done),        PR_TRUE},
  {"FTC_Manager_New",         NS_FT2_OFFSET(nsFTC_Manager_New),         PR_TRUE},
  {"FTC_ImageCache_New",      NS_FT2_OFFSET(nsFTC_Image_Cache_New),     PR_TRUE},
// #ifdef MOZ_SVG
  {"FT_Glyph_Transform",      NS_FT2_OFFSET(nsFT_Glyph_Transform),      PR_TRUE},
  {"FT_Get_Kerning",          NS_FT2_OFFSET(nsFT_Get_Kerning),          PR_TRUE},

} 
 
NS_IMETHODIMP
nsFreeType2::ImageCacheLookup(FTC_ImageCache cache, FTC_ImageType *desc,
                              FT_UInt glyphID, FT_Glyph *glyph)
{ 
  // call the FreeType2 function via the function pointer

} 
 
NS_IMETHODIMP
nsFreeType2::ManagerLookupFace(FTC_Manager manager, FTC_FaceID face_id,
                               FT_Face *face)
{ 
  // call the FreeType2 function via the function pointer
  FT_Error error = nsFTC_Manager_LookupFace(manager, face_id, face);
  return error ? NS_ERROR_FAILURE : NS_OK;
} 
 

} 
 
NS_IMETHODIMP
nsFreeType2::ImageCacheNew(FTC_Manager manager, FTC_ImageCache *cache)
{ 
  // call the FreeType2 function via the function pointer
  FT_Error error = nsFTC_Image_Cache_New(manager, cache);

} 
 
NS_IMETHODIMP
nsFreeType2::GetImageCache(FTC_ImageCache *aCache)
{
  *aCache = mImageCache;
  return NS_OK;




typedef FT_Error (*FT_New_Face_t)(FT_Library, const char*, FT_Long, FT_Face*);
typedef FT_Error (*FT_Set_Charmap_t)(FT_Face face, FT_CharMap  charmap);
typedef FT_Error (*FTC_Image_Cache_Lookup_t)
                      (FTC_ImageCache, FTC_ImageType*, FT_UInt, FT_Glyph*);
typedef FT_Error (*FTC_Manager_LookupFace_t)
                      (FTC_Manager, FTC_FaceID, FT_Face*);
typedef FT_Error (*FTC_Manager_Done_t)(FTC_Manager);
typedef FT_Error (*FTC_Manager_New_t)(FT_Library, FT_UInt, FT_UInt, FT_ULong,
                       FTC_Face_Requester, FT_Pointer, FTC_Manager*);
typedef FT_Error (*FTC_Image_Cache_New_t)(FTC_Manager, FTC_ImageCache*);
// #ifdef MOZ_SVG
typedef FT_Error (*FT_Glyph_Transform_t)(FT_Glyph, FT_Matrix*, FT_Vector*);
typedef FT_Error (*FT_Get_Kerning_t)

  FT_Outline_Decompose_t    nsFT_Outline_Decompose;
  FT_Set_Charmap_t          nsFT_Set_Charmap;
  FTC_Image_Cache_Lookup_t  nsFTC_Image_Cache_Lookup;
  FTC_Manager_LookupFace_t  nsFTC_Manager_LookupFace;
  FTC_Manager_Done_t        nsFTC_Manager_Done;
  FTC_Manager_New_t         nsFTC_Manager_New;
  FTC_Image_Cache_New_t     nsFTC_Image_Cache_New;

  PRLibrary      *mSharedLib;
  FT_Library      mFreeTypeLibrary;
  FTC_Manager     mFTCacheManager;
  FTC_ImageCache  mImageCache;

  static nsHashtable   *sFontFamilies;
  static nsHashtable   *sRange1CharSetNames;




  
  mPixelSize = NSToIntRound(app2dev * mFont->size);

  mImageDesc->face_id = (FTC_FaceID)&mEntry;
  mImageDesc->width  = mPixelSize;
  mImageDesc->height = mPixelSize;
  mImageDesc->flags = 0;

  nsresult rv;
  mFt2 = do_GetService(NS_FREETYPE2_CONTRACTID, &rv);

  if (!face)
    return 0;

  FTC_ImageCache iCache;
  nsresult rv = mFt2->GetImageCache(&iCache);
  if (NS_FAILED(rv)) {
    NS_ERROR("Failed to get Image Cache");

  
  FTC_Manager cManager;
  mFt2->GetFTCacheManager(&cManager);
  nsresult rv = mFt2->ManagerLookupFace(cManager, mImageDesc->face_id,
                                        &face);
  NS_ASSERTION(rv==0, "failed to get face/size");
  if (rv)
    return nsnull;

  mEntry->GetFamilyName(fontName);
  mEntry->GetStyleName(styleName);
  
  mImageDesc->face_id = (FTC_FaceID)&mEntry;
  // TT glyph has no relation to size
  mImageDesc->width  = 16;
  mImageDesc->height = 16;
  mImageDesc->flags = 0;
  FT_Face face = nsnull;
  FTC_Manager cManager;
  mFt2->GetFTCacheManager(&cManager);
  nsresult rv = mFt2->ManagerLookupFace(cManager, mImageDesc->face_id,
                                        &face);
  if (NS_FAILED(rv))
    return;
 

Lines 319-325 protected: Link Here

(-)mozilla/gfx/src/ps/nsFontMetricsPS.h (-2 / +2 lines)
319	nsCOMPtr<nsITrueTypeFontCatalogEntry> mFaceID;	319	nsCOMPtr<nsITrueTypeFontCatalogEntry> mFaceID;
320	nsCOMPtr<nsIFreeType2> mFt2;	320	nsCOMPtr<nsIFreeType2> mFt2;
321	PRUint16 mPixelSize;	321	PRUint16 mPixelSize;
322	FTC_Image_Desc mImageDesc;	322	FTC_ImageType mImageDesc;
323		323
324		324
325	static PRBool AddUserPref(nsIAtom *aLang, const nsFont& aFont,	325	static PRBool AddUserPref(nsIAtom *aLang, const nsFont& aFont,
Lines 362-368 public: Link Here
362	protected:	362	protected:
363	nsCOMPtr<nsITrueTypeFontCatalogEntry> mEntry;	363	nsCOMPtr<nsITrueTypeFontCatalogEntry> mEntry;
364	nsCOMPtr<nsIFreeType2> mFt2;	364	nsCOMPtr<nsIFreeType2> mFt2;
365	FTC_Image_Desc mImageDesc;	365	FTC_ImageType mImageDesc;
366	};	366	};
367	#endif	367	#endif
368		368




  FTC_Manager mgr;
  nsresult rv;
  mFt2->GetFTCacheManager(&mgr);
  rv = mFt2->ManagerLookupFace(mgr, mImageDesc->face_id, &face);
  NS_ASSERTION(NS_SUCCEEDED(rv), "failed to get face/size");
  if (NS_FAILED(rv))
    return nsnull;

  PRBool embedded_bimap = PR_FALSE;
  mFaceID = aFaceID;
  mPixelSize = aPixelSize;
  mImageDesc->face_id = (FTC_FaceID)&mFaceID;
  mImageDesc->width  = aPixelSize;
  mImageDesc->height = aPixelSize;
  mImageDesc->flags = 0;

  if (aPixelSize < nsFreeType2::gAntiAliasMinimum) {
    mImageDesc.image_type |= ftc_image_mono;
    anti_alias = PR_FALSE;
  }

  if (nsFreeType2::gFreeType2Autohinted)
    mImageDesc.image_type |= ftc_image_flag_autohinted;

  if (nsFreeType2::gFreeType2Unhinted)
    mImageDesc.image_type |= ftc_image_flag_unhinted;

  PRUint32  num_embedded_bitmaps, i;
  PRInt32*  embedded_bitmapheights;
  mFaceID->GetEmbeddedBitmapHeights(&num_embedded_bitmaps,

        if (embedded_bitmapheights[i] == aPixelSize) {
          embedded_bimap = PR_TRUE;
          // unhinted must be set for embedded bitmaps to be used
          mImageDesc.image_type |= ftc_image_flag_unhinted;
          break;
        }
      }

  if (!face)
    return NS_ERROR_FAILURE;

  FTC_ImageCache icache;
  mFt2->GetImageCache(&icache);
  if (!icache)
    return NS_ERROR_FAILURE;

  if (!face)
    return 0;

  FTC_ImageCache icache;
  mFt2->GetImageCache(&icache);
  if (!icache)
    return 0;

    if (y%4==0) (*blendPixelFunc)(sub_image, y, ascent-1, black, 255/2);
#endif

  FTC_ImageCache icache;
  mFt2->GetImageCache(&icache);
  if (!icache)
    return 0;

Lines 110-116 protected: Link Here

(-)mozilla/gfx/src/x11shared/nsFontFreeType.h (-1 / +1 lines)
110	XImage *GetXImage(PRUint32 width, PRUint32 height);	110	XImage *GetXImage(PRUint32 width, PRUint32 height);
111	nsITrueTypeFontCatalogEntry *mFaceID;	111	nsITrueTypeFontCatalogEntry *mFaceID;
112	PRUint16 mPixelSize;	112	PRUint16 mPixelSize;
113	FTC_Image_Desc mImageDesc;	113	FTC_ImageType mImageDesc;
114	nsCOMPtr<nsIFreeType2> mFt2;	114	nsCOMPtr<nsIFreeType2> mFt2;
115	};	115	};
116		116

Return to bug 59849

Lines 76-85 native FT_Pointer(FT_Pointer); Link Here

(-)mozilla/gfx/idl/nsIFreeType2.idl (-7 / +8 lines)
76	native FT_Sfnt_Tag(FT_Sfnt_Tag);	76	native FT_Sfnt_Tag(FT_Sfnt_Tag);
77	native FT_Size(FT_Size);	77	native FT_Size(FT_Size);
78		78
79	[ptr] native FTC_Image_Desc_p(FTC_Image_Desc);	79	[ptr] native FTC_ImageType_p(FTC_ImageType);
80	native FTC_Face_Requester(FTC_Face_Requester);	80	native FTC_Face_Requester(FTC_Face_Requester);
81	native FTC_Font(FTC_Font);	81	native FTC_Font(FTC_Font);
82	native FTC_Image_Cache(FTC_Image_Cache);	82	native FTC_FaceID(FTC_FaceID);
		83	native FTC_ImageCache(FTC_ImageCache);
83	native FTC_Manager(FTC_Manager);	84	native FTC_Manager(FTC_Manager);
84		85
85	// #ifdef MOZ_SVG	86	// #ifdef MOZ_SVG
Lines 99-105 interface nsIFreeType2 : nsISupports Link Here
99		100
100	readonly attribute FT_Library library;	101	readonly attribute FT_Library library;
101	readonly attribute FTC_Manager FTCacheManager;	102	readonly attribute FTC_Manager FTCacheManager;
102	readonly attribute FTC_Image_Cache ImageCache;	103	readonly attribute FTC_ImageCache ImageCache;
103		104
104	void doneFace(in FT_Face face);	105	void doneFace(in FT_Face face);
105	void doneFreeType(in FT_Library lib);	106	void doneFreeType(in FT_Library lib);
Lines 115-130 interface nsIFreeType2 : nsISupports Link Here
115	void outlineDecompose(in FT_Outline_p outline,	116	void outlineDecompose(in FT_Outline_p outline,
116	in const_FT_Outline_Funcs_p funcs, in voidPtr p);	117	in const_FT_Outline_Funcs_p funcs, in voidPtr p);
117	void setCharmap(in FT_Face face, in FT_CharMap charmap);	118	void setCharmap(in FT_Face face, in FT_CharMap charmap);
118	void imageCacheLookup(in FTC_Image_Cache cache, in FTC_Image_Desc_p desc,	119	void imageCacheLookup(in FTC_ImageCache cache, in FTC_ImageType_p desc,
119	in FT_UInt gindex, out FT_Glyph glyph);	120	in FT_UInt gindex, out FT_Glyph glyph);
120	void managerLookupSize(in FTC_Manager manager, in FTC_Font font,	121	void managerLookupFace(in FTC_Manager manager, in FTC_FaceID face_id,
121	out FT_Face face, out FT_Size size);	122	out FT_Face face);
122	void managerDone(in FTC_Manager manager);	123	void managerDone(in FTC_Manager manager);
123	void managerNew(in FT_Library lib, in FT_UInt max_faces,	124	void managerNew(in FT_Library lib, in FT_UInt max_faces,
124	in FT_UInt max_sizes, in FT_ULong max_bytes,	125	in FT_UInt max_sizes, in FT_ULong max_bytes,
125	in FTC_Face_Requester requester, in FT_Pointer req_data,	126	in FTC_Face_Requester requester, in FT_Pointer req_data,
126	out FTC_Manager manager);	127	out FTC_Manager manager);
127	void imageCacheNew(in FTC_Manager manager, out FTC_Image_Cache cache);	128	void imageCacheNew(in FTC_Manager manager, out FTC_ImageCache cache);
128	/* #ifdef MOZ_SVG */	129	/* #ifdef MOZ_SVG */
129	void glyphTransform(in FT_Glyph glyph, in FT_Matrix_p matrix,	130	void glyphTransform(in FT_Glyph glyph, in FT_Matrix_p matrix,
130	in FT_Vector_p delta);	131	in FT_Vector_p delta);

Lines 120-132 typedef FT_Error (*FT_Outline_Decompose_ Link Here

(-)mozilla/gfx/src/freetype/nsFreeType.h (-6 / +6 lines)
120	typedef FT_Error (FT_New_Face_t)(FT_Library, const char, FT_Long, FT_Face*);	120	typedef FT_Error (FT_New_Face_t)(FT_Library, const char, FT_Long, FT_Face*);
121	typedef FT_Error (*FT_Set_Charmap_t)(FT_Face face, FT_CharMap charmap);	121	typedef FT_Error (*FT_Set_Charmap_t)(FT_Face face, FT_CharMap charmap);
122	typedef FT_Error (*FTC_Image_Cache_Lookup_t)	122	typedef FT_Error (*FTC_Image_Cache_Lookup_t)
123	(FTC_Image_Cache, FTC_Image_Desc, FT_UInt, FT_Glyph);	123	(FTC_ImageCache, FTC_ImageType, FT_UInt, FT_Glyph);
124	typedef FT_Error (*FTC_Manager_Lookup_Size_t)	124	typedef FT_Error (*FTC_Manager_LookupFace_t)
125	(FTC_Manager, FTC_Font, FT_Face, FT_Size);	125	(FTC_Manager, FTC_FaceID, FT_Face*);
126	typedef FT_Error (*FTC_Manager_Done_t)(FTC_Manager);	126	typedef FT_Error (*FTC_Manager_Done_t)(FTC_Manager);
127	typedef FT_Error (*FTC_Manager_New_t)(FT_Library, FT_UInt, FT_UInt, FT_ULong,	127	typedef FT_Error (*FTC_Manager_New_t)(FT_Library, FT_UInt, FT_UInt, FT_ULong,
128	FTC_Face_Requester, FT_Pointer, FTC_Manager*);	128	FTC_Face_Requester, FT_Pointer, FTC_Manager*);
129	typedef FT_Error (FTC_Image_Cache_New_t)(FTC_Manager, FTC_Image_Cache);	129	typedef FT_Error (FTC_Image_Cache_New_t)(FTC_Manager, FTC_ImageCache);
130	// #ifdef MOZ_SVG	130	// #ifdef MOZ_SVG
131	typedef FT_Error (FT_Glyph_Transform_t)(FT_Glyph, FT_Matrix, FT_Vector*);	131	typedef FT_Error (FT_Glyph_Transform_t)(FT_Glyph, FT_Matrix, FT_Vector*);
132	typedef FT_Error (*FT_Get_Kerning_t)	132	typedef FT_Error (*FT_Get_Kerning_t)
Lines 181-187 protected: Link Here
181	FT_Outline_Decompose_t nsFT_Outline_Decompose;	181	FT_Outline_Decompose_t nsFT_Outline_Decompose;
182	FT_Set_Charmap_t nsFT_Set_Charmap;	182	FT_Set_Charmap_t nsFT_Set_Charmap;
183	FTC_Image_Cache_Lookup_t nsFTC_Image_Cache_Lookup;	183	FTC_Image_Cache_Lookup_t nsFTC_Image_Cache_Lookup;
184	FTC_Manager_Lookup_Size_t nsFTC_Manager_Lookup_Size;	184	FTC_Manager_LookupFace_t nsFTC_Manager_LookupFace;
185	FTC_Manager_Done_t nsFTC_Manager_Done;	185	FTC_Manager_Done_t nsFTC_Manager_Done;
186	FTC_Manager_New_t nsFTC_Manager_New;	186	FTC_Manager_New_t nsFTC_Manager_New;
187	FTC_Image_Cache_New_t nsFTC_Image_Cache_New;	187	FTC_Image_Cache_New_t nsFTC_Image_Cache_New;
Lines 229-235 protected: Link Here
229	PRLibrary *mSharedLib;	229	PRLibrary *mSharedLib;
230	FT_Library mFreeTypeLibrary;	230	FT_Library mFreeTypeLibrary;
231	FTC_Manager mFTCacheManager;	231	FTC_Manager mFTCacheManager;
232	FTC_Image_Cache mImageCache;	232	FTC_ImageCache mImageCache;
233		233
234	static nsHashtable *sFontFamilies;	234	static nsHashtable *sFontFamilies;
235	static nsHashtable *sRange1CharSetNames;	235	static nsHashtable *sRange1CharSetNames;

Lines 1140-1149 nsFontPSFreeType::Init(nsITrueTypeFontCa Link Here

(-)mozilla/gfx/src/ps/nsFontMetricsPS.cpp (-13 / +13 lines)
1140		1140
1141	mPixelSize = NSToIntRound(app2dev * mFont->size);	1141	mPixelSize = NSToIntRound(app2dev * mFont->size);
1142		1142
1143	mImageDesc.font.face_id = (void*)mEntry;	1143	mImageDesc->face_id = (FTC_FaceID)&mEntry;
1144	mImageDesc.font.pix_width = mPixelSize;	1144	mImageDesc->width = mPixelSize;
1145	mImageDesc.font.pix_height = mPixelSize;	1145	mImageDesc->height = mPixelSize;
1146	mImageDesc.image_type = 0;	1146	mImageDesc->flags = 0;
1147		1147
1148	nsresult rv;	1148	nsresult rv;
1149	mFt2 = do_GetService(NS_FREETYPE2_CONTRACTID, &rv);	1149	mFt2 = do_GetService(NS_FREETYPE2_CONTRACTID, &rv);
Lines 1189-1195 nsFontPSFreeType::GetWidth(const PRUnich Link Here
1189	if (!face)	1189	if (!face)
1190	return 0;	1190	return 0;
1191		1191
1192	FTC_Image_Cache iCache;	1192	FTC_ImageCache iCache;
1193	nsresult rv = mFt2->GetImageCache(&iCache);	1193	nsresult rv = mFt2->GetImageCache(&iCache);
1194	if (NS_FAILED(rv)) {	1194	if (NS_FAILED(rv)) {
1195	NS_ERROR("Failed to get Image Cache");	1195	NS_ERROR("Failed to get Image Cache");
Lines 1227-1234 nsFontPSFreeType::getFTFace() Link Here
1227		1227
1228	FTC_Manager cManager;	1228	FTC_Manager cManager;
1229	mFt2->GetFTCacheManager(&cManager);	1229	mFt2->GetFTCacheManager(&cManager);
1230	nsresult rv = mFt2->ManagerLookupSize(cManager, &mImageDesc.font,	1230	nsresult rv = mFt2->ManagerLookupFace(cManager, mImageDesc->face_id,
1231	&face, nsnull);	1231	&face);
1232	NS_ASSERTION(rv==0, "failed to get face/size");	1232	NS_ASSERTION(rv==0, "failed to get face/size");
1233	if (rv)	1233	if (rv)
1234	return nsnull;	1234	return nsnull;
Lines 1621-1636 void nsFT2Type8Generator::GeneratePSFont Link Here
1621	mEntry->GetFamilyName(fontName);	1621	mEntry->GetFamilyName(fontName);
1622	mEntry->GetStyleName(styleName);	1622	mEntry->GetStyleName(styleName);
1623		1623
1624	mImageDesc.font.face_id = (void*)mEntry;	1624	mImageDesc->face_id = (FTC_FaceID)&mEntry;
1625	// TT glyph has no relation to size	1625	// TT glyph has no relation to size
1626	mImageDesc.font.pix_width = 16;	1626	mImageDesc->width = 16;
1627	mImageDesc.font.pix_height = 16;	1627	mImageDesc->height = 16;
1628	mImageDesc.image_type = 0;	1628	mImageDesc->flags = 0;
1629	FT_Face face = nsnull;	1629	FT_Face face = nsnull;
1630	FTC_Manager cManager;	1630	FTC_Manager cManager;
1631	mFt2->GetFTCacheManager(&cManager);	1631	mFt2->GetFTCacheManager(&cManager);
1632	nsresult rv = mFt2->ManagerLookupSize(cManager, &mImageDesc.font,	1632	nsresult rv = mFt2->ManagerLookupFace(cManager, mImageDesc->face_id,
1633	&face, nsnull);	1633	&face);
1634	if (NS_FAILED(rv))	1634	if (NS_FAILED(rv))
1635	return;	1635	return;
1636		1636

Lines 177-183 nsFreeTypeFont::getFTFace() Link Here

(-)mozilla/gfx/src/x11shared/nsFontFreeType.cpp (-16 / +8 lines)
177	FTC_Manager mgr;	177	FTC_Manager mgr;
178	nsresult rv;	178	nsresult rv;
179	mFt2->GetFTCacheManager(&mgr);	179	mFt2->GetFTCacheManager(&mgr);
180	rv = mFt2->ManagerLookupSize(mgr, &mImageDesc.font, &face, nsnull);	180	rv = mFt2->ManagerLookupFace(mgr, mImageDesc->face_id, &face);
181	NS_ASSERTION(NS_SUCCEEDED(rv), "failed to get face/size");	181	NS_ASSERTION(NS_SUCCEEDED(rv), "failed to get face/size");
182	if (NS_FAILED(rv))	182	if (NS_FAILED(rv))
183	return nsnull;	183	return nsnull;
Lines 191-212 nsFreeTypeFont::nsFreeTypeFont(nsITrueTy Link Here
191	PRBool embedded_bimap = PR_FALSE;	191	PRBool embedded_bimap = PR_FALSE;
192	mFaceID = aFaceID;	192	mFaceID = aFaceID;
193	mPixelSize = aPixelSize;	193	mPixelSize = aPixelSize;
194	mImageDesc.font.face_id = (void*)mFaceID;	194	mImageDesc->face_id = (FTC_FaceID)&mFaceID;
195	mImageDesc.font.pix_width = aPixelSize;	195	mImageDesc->width = aPixelSize;
196	mImageDesc.font.pix_height = aPixelSize;	196	mImageDesc->height = aPixelSize;
197	mImageDesc.image_type = 0;	197	mImageDesc->flags = 0;
198		198
199	if (aPixelSize < nsFreeType2::gAntiAliasMinimum) {	199	if (aPixelSize < nsFreeType2::gAntiAliasMinimum) {
200	mImageDesc.image_type \|= ftc_image_mono;
201	anti_alias = PR_FALSE;	200	anti_alias = PR_FALSE;
202	}	201	}
203		202
204	if (nsFreeType2::gFreeType2Autohinted)
205	mImageDesc.image_type \|= ftc_image_flag_autohinted;
206
207	if (nsFreeType2::gFreeType2Unhinted)
208	mImageDesc.image_type \|= ftc_image_flag_unhinted;
209
210	PRUint32 num_embedded_bitmaps, i;	203	PRUint32 num_embedded_bitmaps, i;
211	PRInt32* embedded_bitmapheights;	204	PRInt32* embedded_bitmapheights;
212	mFaceID->GetEmbeddedBitmapHeights(&num_embedded_bitmaps,	205	mFaceID->GetEmbeddedBitmapHeights(&num_embedded_bitmaps,
Lines 218-224 nsFreeTypeFont::nsFreeTypeFont(nsITrueTy Link Here
218	if (embedded_bitmapheights[i] == aPixelSize) {	211	if (embedded_bitmapheights[i] == aPixelSize) {
219	embedded_bimap = PR_TRUE;	212	embedded_bimap = PR_TRUE;
220	// unhinted must be set for embedded bitmaps to be used	213	// unhinted must be set for embedded bitmaps to be used
221	mImageDesc.image_type \|= ftc_image_flag_unhinted;
222	break;	214	break;
223	}	215	}
224	}	216	}
Lines 312-318 nsFreeTypeFont::doGetBoundingMetrics(con Link Here
312	if (!face)	304	if (!face)
313	return NS_ERROR_FAILURE;	305	return NS_ERROR_FAILURE;
314		306
315	FTC_Image_Cache icache;	307	FTC_ImageCache icache;
316	mFt2->GetImageCache(&icache);	308	mFt2->GetImageCache(&icache);
317	if (!icache)	309	if (!icache)
318	return NS_ERROR_FAILURE;	310	return NS_ERROR_FAILURE;
Lines 401-407 nsFreeTypeFont::GetWidth(const PRUnichar Link Here
401	if (!face)	393	if (!face)
402	return 0;	394	return 0;
403		395
404	FTC_Image_Cache icache;	396	FTC_ImageCache icache;
405	mFt2->GetImageCache(&icache);	397	mFt2->GetImageCache(&icache);
406	if (!icache)	398	if (!icache)
407	return 0;	399	return 0;
Lines 723-729 nsFreeTypeXImage::DrawString(nsRendering Link Here
723	if (y%4==0) (*blendPixelFunc)(sub_image, y, ascent-1, black, 255/2);	715	if (y%4==0) (*blendPixelFunc)(sub_image, y, ascent-1, black, 255/2);
724	#endif	716	#endif
725		717
726	FTC_Image_Cache icache;	718	FTC_ImageCache icache;
727	mFt2->GetImageCache(&icache);	719	mFt2->GetImageCache(&icache);
728	if (!icache)	720	if (!icache)
729	return 0;	721	return 0;

Lines 110-120 FtFuncList nsFreeType2::FtFuncs [] = { Link Here

(-)mozilla/gfx/src/freetype/nsFreeType.cpp (-9 / +9 lines)
110	{"FT_New_Face", NS_FT2_OFFSET(nsFT_New_Face), PR_TRUE},	110	{"FT_New_Face", NS_FT2_OFFSET(nsFT_New_Face), PR_TRUE},
111	{"FT_Outline_Decompose", NS_FT2_OFFSET(nsFT_Outline_Decompose), PR_TRUE},	111	{"FT_Outline_Decompose", NS_FT2_OFFSET(nsFT_Outline_Decompose), PR_TRUE},
112	{"FT_Set_Charmap", NS_FT2_OFFSET(nsFT_Set_Charmap), PR_TRUE},	112	{"FT_Set_Charmap", NS_FT2_OFFSET(nsFT_Set_Charmap), PR_TRUE},
113	{"FTC_Image_Cache_Lookup", NS_FT2_OFFSET(nsFTC_Image_Cache_Lookup), PR_TRUE},	113	{"FTC_ImageCache_Lookup", NS_FT2_OFFSET(nsFTC_Image_Cache_Lookup), PR_TRUE},
114	{"FTC_Manager_Lookup_Size", NS_FT2_OFFSET(nsFTC_Manager_Lookup_Size), PR_TRUE},	114	{"FTC_Manager_LookupFace", NS_FT2_OFFSET(nsFTC_Manager_LookupFace), PR_TRUE},
115	{"FTC_Manager_Done", NS_FT2_OFFSET(nsFTC_Manager_Done), PR_TRUE},	115	{"FTC_Manager_Done", NS_FT2_OFFSET(nsFTC_Manager_Done), PR_TRUE},
116	{"FTC_Manager_New", NS_FT2_OFFSET(nsFTC_Manager_New), PR_TRUE},	116	{"FTC_Manager_New", NS_FT2_OFFSET(nsFTC_Manager_New), PR_TRUE},
117	{"FTC_Image_Cache_New", NS_FT2_OFFSET(nsFTC_Image_Cache_New), PR_TRUE},	117	{"FTC_ImageCache_New", NS_FT2_OFFSET(nsFTC_Image_Cache_New), PR_TRUE},
118	// #ifdef MOZ_SVG	118	// #ifdef MOZ_SVG
119	{"FT_Glyph_Transform", NS_FT2_OFFSET(nsFT_Glyph_Transform), PR_TRUE},	119	{"FT_Glyph_Transform", NS_FT2_OFFSET(nsFT_Glyph_Transform), PR_TRUE},
120	{"FT_Get_Kerning", NS_FT2_OFFSET(nsFT_Get_Kerning), PR_TRUE},	120	{"FT_Get_Kerning", NS_FT2_OFFSET(nsFT_Get_Kerning), PR_TRUE},
Lines 282-288 nsFreeType2::SetCharmap(FT_Face face, FT Link Here
282	}	282	}
283		283
284	NS_IMETHODIMP	284	NS_IMETHODIMP
285	nsFreeType2::ImageCacheLookup(FTC_Image_Cache cache, FTC_Image_Desc *desc,	285	nsFreeType2::ImageCacheLookup(FTC_ImageCache cache, FTC_ImageType *desc,
286	FT_UInt glyphID, FT_Glyph *glyph)	286	FT_UInt glyphID, FT_Glyph *glyph)
287	{	287	{
288	// call the FreeType2 function via the function pointer	288	// call the FreeType2 function via the function pointer
Lines 291-301 nsFreeType2::ImageCacheLookup(FTC_Image_ Link Here
291	}	291	}
292		292
293	NS_IMETHODIMP	293	NS_IMETHODIMP
294	nsFreeType2::ManagerLookupSize(FTC_Manager manager, FTC_Font font,	294	nsFreeType2::ManagerLookupFace(FTC_Manager manager, FTC_FaceID face_id,
295	FT_Face face, FT_Size size)	295	FT_Face *face)
296	{	296	{
297	// call the FreeType2 function via the function pointer	297	// call the FreeType2 function via the function pointer
298	FT_Error error = nsFTC_Manager_Lookup_Size(manager, font, face, size);	298	FT_Error error = nsFTC_Manager_LookupFace(manager, face_id, face);
299	return error ? NS_ERROR_FAILURE : NS_OK;	299	return error ? NS_ERROR_FAILURE : NS_OK;
300	}	300	}
301		301
Lines 320-326 nsFreeType2::ManagerNew(FT_Library libra Link Here
320	}	320	}
321		321
322	NS_IMETHODIMP	322	NS_IMETHODIMP
323	nsFreeType2::ImageCacheNew(FTC_Manager manager, FTC_Image_Cache *cache)	323	nsFreeType2::ImageCacheNew(FTC_Manager manager, FTC_ImageCache *cache)
324	{	324	{
325	// call the FreeType2 function via the function pointer	325	// call the FreeType2 function via the function pointer
326	FT_Error error = nsFTC_Image_Cache_New(manager, cache);	326	FT_Error error = nsFTC_Image_Cache_New(manager, cache);
Lines 389-395 nsFreeType2::SupportsExtFunc(PRBool *res Link Here
389	}	389	}
390		390
391	NS_IMETHODIMP	391	NS_IMETHODIMP
392	nsFreeType2::GetImageCache(FTC_Image_Cache *aCache)	392	nsFreeType2::GetImageCache(FTC_ImageCache *aCache)
393	{	393	{
394	*aCache = mImageCache;	394	*aCache = mImageCache;
395	return NS_OK;	395	return NS_OK;