Attachment #50409 for bug #74343

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

Lines 28-34 Link Here

(-)../Orig/mozilla/extensions/transformiix/source/base/ErrorObserver.h (-1 / +2 lines)
28		28
29	#include "baseutils.h"	29	#include "baseutils.h"
30	#include "txError.h"	30	#include "txError.h"
31	#include <iostream.h>	31	#include <iostream>
		32	using namespace std;
32	class nsAString;	33	class nsAString;
33		34
34	/**	35	/**




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);




  
  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;





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;




  {"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;

Lines 320-326 Link Here

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

Lines 110-116 Link Here

(-)../Orig/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




  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; 

Return to bug 74343

Lines 76-85 Link Here

(-)../Orig/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 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 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 1141-1150 Link Here

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

Lines 177-183 Link Here

(-)../Orig/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 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 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 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 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 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 104-116 Link Here

(-)../Orig/mozilla/gfx/src/freetype/nsFreeType.h (-6 / +6 lines)
104	typedef FT_Error (FT_New_Face_t)(FT_Library, const char, FT_Long, FT_Face*);	104	typedef FT_Error (FT_New_Face_t)(FT_Library, const char, FT_Long, FT_Face*);
105	typedef FT_Error (*FT_Set_Charmap_t)(FT_Face face, FT_CharMap charmap);	105	typedef FT_Error (*FT_Set_Charmap_t)(FT_Face face, FT_CharMap charmap);
106	typedef FT_Error (*FTC_Image_Cache_Lookup_t)	106	typedef FT_Error (*FTC_Image_Cache_Lookup_t)
107	(FTC_Image_Cache, FTC_Image_Desc, FT_UInt, FT_Glyph);	107	(FTC_ImageCache, FTC_ImageType, FT_UInt, FT_Glyph);
108	typedef FT_Error (*FTC_Manager_Lookup_Size_t)	108	typedef FT_Error (*FTC_Manager_LookupFace_t)
109	(FTC_Manager, FTC_Font, FT_Face, FT_Size);	109	(FTC_Manager, FTC_FaceID, FT_Face*);
110	typedef FT_Error (*FTC_Manager_Done_t)(FTC_Manager);	110	typedef FT_Error (*FTC_Manager_Done_t)(FTC_Manager);
111	typedef FT_Error (*FTC_Manager_New_t)(FT_Library, FT_UInt, FT_UInt, FT_ULong,	111	typedef FT_Error (*FTC_Manager_New_t)(FT_Library, FT_UInt, FT_UInt, FT_ULong,
112	FTC_Face_Requester, FT_Pointer, FTC_Manager*);	112	FTC_Face_Requester, FT_Pointer, FTC_Manager*);
113	typedef FT_Error (FTC_Image_Cache_New_t)(FTC_Manager, FTC_Image_Cache);	113	typedef FT_Error (FTC_Image_Cache_New_t)(FTC_Manager, FTC_ImageCache);
114	// #ifdef MOZ_SVG	114	// #ifdef MOZ_SVG
115	typedef FT_Error (FT_Glyph_Transform_t)(FT_Glyph, FT_Matrix, FT_Vector*);	115	typedef FT_Error (FT_Glyph_Transform_t)(FT_Glyph, FT_Matrix, FT_Vector*);
116	typedef FT_Error (*FT_Get_Kerning_t)	116	typedef FT_Error (*FT_Get_Kerning_t)
Lines 165-171 Link Here
165	FT_Outline_Decompose_t nsFT_Outline_Decompose;	165	FT_Outline_Decompose_t nsFT_Outline_Decompose;
166	FT_Set_Charmap_t nsFT_Set_Charmap;	166	FT_Set_Charmap_t nsFT_Set_Charmap;
167	FTC_Image_Cache_Lookup_t nsFTC_Image_Cache_Lookup;	167	FTC_Image_Cache_Lookup_t nsFTC_Image_Cache_Lookup;
168	FTC_Manager_Lookup_Size_t nsFTC_Manager_Lookup_Size;	168	FTC_Manager_LookupFace_t nsFTC_Manager_LookupFace;
169	FTC_Manager_Done_t nsFTC_Manager_Done;	169	FTC_Manager_Done_t nsFTC_Manager_Done;
170	FTC_Manager_New_t nsFTC_Manager_New;	170	FTC_Manager_New_t nsFTC_Manager_New;
171	FTC_Image_Cache_New_t nsFTC_Image_Cache_New;	171	FTC_Image_Cache_New_t nsFTC_Image_Cache_New;
Lines 213-219 Link Here
213	PRLibrary *mSharedLib;	213	PRLibrary *mSharedLib;
214	FT_Library mFreeTypeLibrary;	214	FT_Library mFreeTypeLibrary;
215	FTC_Manager mFTCacheManager;	215	FTC_Manager mFTCacheManager;
216	FTC_Image_Cache mImageCache;	216	FTC_ImageCache mImageCache;
217		217
218	static nsHashtable *sFontFamilies;	218	static nsHashtable *sFontFamilies;
219	static nsHashtable *sRange1CharSetNames;	219	static nsHashtable *sRange1CharSetNames;

Lines 110-120 Link Here

(-)../Orig/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 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 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 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 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;