Attachment #752 for bug #6151

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




dnl = Xft
dnl ========================================================
MOZ_ARG_ENABLE_BOOL(xft,
[  --enable-xft            Enable Xft support ],
    MOZ_ENABLE_XFT=1,
    MOZ_ENABLE_XFT= )

if test "$MOZ_ENABLE_XFT" && test "$MOZ_ENABLE_FREETYPE2"; then
    AC_MSG_ERROR([Cannot enable XFT and FREETYPE2 at the same time.])
fi

if test "$MOZ_ENABLE_XFT"
then
    AC_DEFINE(MOZ_ENABLE_XFT)
    PKG_CHECK_MODULES(MOZ_XFT, xft)
    if test "$MOZ_ENABLE_GTK2"; then
        PKG_CHECK_MODULES(_PANGOCHK, pango >= 1.1.0)
    fi




		nsIFontList.idl \
		nsIScriptableRegion.idl \
		nsIScreen.idl \
		nsIScreenManager.idl \
		nsIPrintOptions.idl \
		nsIPrintSettings.idl \
		nsIPrintSettingsService.idl \
		nsIFontCatalogService.idl \
		nsIFreeType2.idl \
		nsIPrintSession.idl \
		gfxIFormats.idl \
		gfxIImageFrame.idl \
		gfxtypes.idl \
		$(NULL)

ifdef MOZ_ENABLE_FREETYPE2
XPIDLSRCS	+= \
		nsIFontCatalogService.idl \
		nsIFreeType2.idl \
		$(NULL)
endif

ifneq (,$(filter mac cocoa,$(MOZ_GFX_TOOLKIT)))
XPIDLSRCS += nsIPrintSettingsX.idl \
		nsIPrintSessionX.idl \
		$(NULL)
endif

ifeq ($(MOZ_GFX_TOOLKIT),windows)




NATIVE_THEME_SUPPORT = 1

CSRCS		= nsPrintdGTK.c

# Code shared between GTK+, Xlib and Xprint gfx modules
X11SHARED_LCPPSRCS = \
		nsAntiAliasedGlyph.cpp \
		nsFontFreeType.cpp \
		nsFT2FontNode.cpp \
		nsFT2FontCatalog.cpp \
		nsX11AlphaBlend.cpp \
		nsXFontAAScaledBitmap.cpp \
		nsXFontNormal.cpp \
		$(NULL)

ifdef MOZ_ENABLE_FREETYPE2
X11SHARED_LCPPSRCS += \
		nsFontFreeType.cpp \
		nsFT2FontNode.cpp \
		nsFT2FontCatalog.cpp \
		$(NULL)
endif
                
CPPSRCS		= \
		nsDeviceContextGTK.cpp \
		nsDeviceContextSpecFactoryG.cpp \
		nsDeviceContextSpecG.cpp \
		nsDrawingSurfaceGTK.cpp \
		nsGfxFactoryGTK.cpp \

endif

LOCAL_INCLUDES	= \
		-I../.. \
		-I$(srcdir)/. \
		-I$(srcdir)/.. \
		-I$(srcdir)/../shared \
		-I$(srcdir)/../freetype \
		-I$(srcdir)/../x11shared \
		$(MOZ_XFT_CFLAGS) \
		$(NULL)

ifdef MOZ_ENABLE_FREETYPE2
INCLUDES        += $(FT2_CFLAGS)
LOCAL_INCLUDES        += -I$(srcdir)/../freetype
endif

ifdef MOZ_ENABLE_XPRINT
export:: $(addprefix $(srcdir)/../xprint/,$(XPU_LCSRCS)) $(addprefix $(srcdir)/../x11shared/,$(X11SHARED_LCPPSRCS))
	$(INSTALL) $^ .
else
export:: $(addprefix $(srcdir)/../x11shared/,$(X11SHARED_LCPPSRCS))




#include "nsPrintfCString.h"
#include "nspr.h"
#include "nsHashtable.h"
#include "nsReadableUtils.h"
#include "nsAString.h"
#include "nsXPIDLString.h"
#include "nsFontDebug.h"
#ifdef MOZ_ENABLE_FREETYPE2
#include "nsFT2FontNode.h"
#include "nsFontFreeType.h"
#endif
#include "nsXFontNormal.h"
#include "nsX11AlphaBlend.h"
#include "nsXFontAAScaledBitmap.h"
#include "nsUnicharUtils.h"
#ifdef ENABLE_X_FONT_BANNING
#include <regex.h>
#endif /* ENABLE_X_FONT_BANNING */

// this factor larger than the height of the display, it's clamped to
// that value instead of the requested size.
#define FONT_MAX_FONT_SCALE 2

#undef NOISY_FONTS
#undef REALLY_NOISY_FONTS

#ifndef MOZ_ENABLE_FREETYPE2
static PRUint32 gFontDebug = 0 | NS_FONT_DEBUG_FONT_SCAN;
#endif

struct nsFontCharSetMap;
struct nsFontFamilyName;
struct nsFontPropertyName;
struct nsFontStyle;
struct nsFontWeight;
struct nsFontLangGroup;

struct nsFontCharSetInfo
{
  const char*            mCharSet;
  nsFontCharSetConverter Convert;
  PRUint8                mSpecialUnderline;
#ifdef MOZ_ENABLE_FREETYPE2
  PRInt32                mCodeRange1Bits;
  PRInt32                mCodeRange2Bits;
#endif
  PRUint16*              mCCMap;
  nsIUnicodeEncoder*     mConverter;
  nsIAtom*               mLangGroup;
  PRBool                 mInitedSizeInfo;
  PRInt32                mOutlineScaleMin;
  PRInt32                mAABitmapScaleMin;
  double                 mAABitmapOversize;

  const PRUnichar* aSrcBuf, PRInt32 aSrcLen, char* aDestBuf, PRInt32 aDestLen);
static gint ISO10646Convert(nsFontCharSetInfo* aSelf, XFontStruct* aFont,
  const PRUnichar* aSrcBuf, PRInt32 aSrcLen, char* aDestBuf, PRInt32 aDestLen);

static nsFontCharSetInfo Unknown = { nsnull };
static nsFontCharSetInfo Special = { nsnull };

#ifdef MOZ_ENABLE_FREETYPE2
static nsFontCharSetInfo USASCII =
  { "us-ascii", SingleByteConvert, 0,
    TT_OS2_CPR1_LATIN1 | TT_OS2_CPR1_MAC_ROMAN,
    TT_OS2_CPR2_CA_FRENCH |  TT_OS2_CPR2_PORTUGESE
    | TT_OS2_CPR2_WE_LATIN1 |  TT_OS2_CPR2_US };
static nsFontCharSetInfo ISO88591 =
  { "ISO-8859-1", SingleByteConvert, 0,

   { "x-mathematica2", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};
static nsFontCharSetInfo Mathematica3 =
   { "x-mathematica3", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};
static nsFontCharSetInfo Mathematica4 =
   { "x-mathematica4", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};
static nsFontCharSetInfo Mathematica5 =
   { "x-mathematica5", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};
#endif /* MATHML */

#else

static nsFontCharSetInfo USASCII =
  { "us-ascii", SingleByteConvert, 0 };
static nsFontCharSetInfo ISO88591 =
  { "ISO-8859-1", SingleByteConvert, 0 };
static nsFontCharSetInfo ISO88592 =
  { "ISO-8859-2", SingleByteConvert, 0 };
static nsFontCharSetInfo ISO88593 =
  { "ISO-8859-3", SingleByteConvert, 0 };
static nsFontCharSetInfo ISO88594 =
  { "ISO-8859-4", SingleByteConvert, 0 };
static nsFontCharSetInfo ISO88595 =
  { "ISO-8859-5", SingleByteConvert, 0 };
static nsFontCharSetInfo ISO88596 =
  { "ISO-8859-6", SingleByteConvert, 0 };
static nsFontCharSetInfo ISO885968x =
  { "x-iso-8859-6-8-x", SingleByteConvert, 0 };
static nsFontCharSetInfo ISO8859616 =
  { "x-iso-8859-6-16", SingleByteConvert, 0 };
static nsFontCharSetInfo IBM1046 =
  { "x-IBM1046", SingleByteConvert, 0 };
static nsFontCharSetInfo ISO88597 =
  { "ISO-8859-7", SingleByteConvert, 0 };
static nsFontCharSetInfo ISO88598 =
  { "ISO-8859-8", SingleByteConvert, 0 };
// change from  
// { "ISO-8859-8", SingleByteConvertReverse, 0, 0, 0 };
// untill we fix the layout and ensure we only call this with pure RTL text
static nsFontCharSetInfo ISO88599 =
  { "ISO-8859-9", SingleByteConvert, 0 };
// no support for iso-8859-10 (Nordic/Icelandic) currently
// static nsFontCharSetInfo ISO885910 =
// { "ISO-8859-10", SingleByteConvert, 0,
//   0, TT_OS2_CPR2_NORDIC | TT_OS2_CPR2_ICELANDIC };
// no support for iso-8859-12 (Vietnamese) currently
// static nsFontCharSetInfo ISO885912 =
// { "ISO-8859-12", SingleByteConvert, 0,
//   TT_OS2_CPR1_VIETNAMESE, 0 };
static nsFontCharSetInfo ISO885913 =
  { "ISO-8859-13", SingleByteConvert, 0 };
static nsFontCharSetInfo ISO885915 =
  { "ISO-8859-15", SingleByteConvert, 0 };
static nsFontCharSetInfo JISX0201 =
  { "jis_0201", SingleByteConvert, 1 };
static nsFontCharSetInfo KOI8R =
  { "KOI8-R", SingleByteConvert, 0 };
static nsFontCharSetInfo KOI8U =
  { "KOI8-U", SingleByteConvert, 0 };
static nsFontCharSetInfo TIS6202 =
/* Added to support thai context sensitive shaping if
 * CTL extension is is in force */
#ifdef SUNCTL
  { "tis620-2", SingleByteConvert, 0 };
#else
  { "windows-874", SingleByteConvert, 0 };
#endif /* SUNCTL */
static nsFontCharSetInfo TIS620 =
  { "TIS-620", SingleByteConvert, 0 };
static nsFontCharSetInfo ISO885911 =
  { "ISO-8859-11", SingleByteConvert, 0 };
static nsFontCharSetInfo Big5 =
  { "x-x-big5", DoubleByteConvert, 1 };
// a kludge to distinguish zh-TW only fonts in Big5 (such as hpbig5-)
// from zh-TW/zh-HK common fonts in Big5 (such as big5-1)
static nsFontCharSetInfo Big5TWHK =
  { "x-x-big5", DoubleByteConvert, 1 };
static nsFontCharSetInfo CNS116431 =
  { "x-cns-11643-1", DoubleByteConvert, 1 };
static nsFontCharSetInfo CNS116432 =
  { "x-cns-11643-2", DoubleByteConvert, 1 };
static nsFontCharSetInfo CNS116433 =
  { "x-cns-11643-3", DoubleByteConvert, 1 };
static nsFontCharSetInfo CNS116434 =
  { "x-cns-11643-4", DoubleByteConvert, 1 };
static nsFontCharSetInfo CNS116435 =
  { "x-cns-11643-5", DoubleByteConvert, 1 };
static nsFontCharSetInfo CNS116436 =
  { "x-cns-11643-6", DoubleByteConvert, 1 };
static nsFontCharSetInfo CNS116437 =
  { "x-cns-11643-7", DoubleByteConvert, 1 };
static nsFontCharSetInfo GB2312 =
  { "gb_2312-80", DoubleByteConvert, 1 };
static nsFontCharSetInfo GB18030_0 =
  { "gb18030.2000-0", DoubleByteConvert, 1 };
static nsFontCharSetInfo GB18030_1 =
  { "gb18030.2000-1", DoubleByteConvert, 1 };
static nsFontCharSetInfo GBK =
  { "x-gbk-noascii", DoubleByteConvert, 1 };
static nsFontCharSetInfo HKSCS =
  { "hkscs-1", DoubleByteConvert, 1 };
static nsFontCharSetInfo JISX0208 =
  { "jis_0208-1983", DoubleByteConvert, 1 };
static nsFontCharSetInfo JISX0212 =
  { "jis_0212-1990", DoubleByteConvert, 1 };
static nsFontCharSetInfo KSC5601 =
  { "ks_c_5601-1987", DoubleByteConvert, 1 };
static nsFontCharSetInfo X11Johab =
  { "x-x11johab", DoubleByteConvert, 1 };
static nsFontCharSetInfo JohabNoAscii =
  { "x-johab-noascii", DoubleByteConvert, 1 };
static nsFontCharSetInfo JamoTTF =
  { "x-koreanjamo-0", DoubleByteConvert, 1 };
static nsFontCharSetInfo TamilTTF =
  { "x-tamilttf-0", DoubleByteConvert, 0 };
static nsFontCharSetInfo CP1250 =
  { "windows-1250", SingleByteConvert, 0 };
static nsFontCharSetInfo CP1251 =
  { "windows-1251", SingleByteConvert, 0 };
static nsFontCharSetInfo CP1252 =
  { "windows-1252", SingleByteConvert, 0 };
static nsFontCharSetInfo CP1253 =
  { "windows-1253", SingleByteConvert, 0 };
static nsFontCharSetInfo CP1257 =
  { "windows-1257", SingleByteConvert, 0 };

#ifdef SUNCTL
/* Hindi range currently unsupported in FT2 range. Change TT* once we 
   arrive at a way to identify hindi */
static nsFontCharSetInfo SunIndic =
  { "x-sun-unicode-india-0", DoubleByteConvert, 0 };
#endif /* SUNCTL */

static nsFontCharSetInfo ISO106461 =
  { nsnull, ISO10646Convert, 1};

static nsFontCharSetInfo AdobeSymbol =
   { "Adobe-Symbol-Encoding", SingleByteConvert, 0 };
static nsFontCharSetInfo AdobeEuro =
  { "x-adobe-euro", SingleByteConvert, 0 };
         
#ifdef MOZ_MATHML
static nsFontCharSetInfo CMCMEX =
   { "x-t1-cmex", SingleByteConvert, 0};
static nsFontCharSetInfo CMCMSY =
   { "x-t1-cmsy", SingleByteConvert, 0};
static nsFontCharSetInfo CMCMR =
   { "x-t1-cmr", SingleByteConvert, 0};
static nsFontCharSetInfo CMCMMI =
   { "x-t1-cmmi", SingleByteConvert, 0};
static nsFontCharSetInfo Mathematica1 =
   { "x-mathematica1", SingleByteConvert, 0};
static nsFontCharSetInfo Mathematica2 =
   { "x-mathematica2", SingleByteConvert, 0}; 
static nsFontCharSetInfo Mathematica3 =
   { "x-mathematica3", SingleByteConvert, 0};
static nsFontCharSetInfo Mathematica4 =
   { "x-mathematica4", SingleByteConvert, 0}; 
static nsFontCharSetInfo Mathematica5 =
   { "x-mathematica5", SingleByteConvert, 0};
#endif /* MATHML */
#endif /* FREETYPE2 */

static nsFontLangGroup FLG_WESTERN = { "x-western",     nsnull };
static nsFontLangGroup FLG_RUSSIAN = { "x-cyrillic",    nsnull };
static nsFontLangGroup FLG_BALTIC  = { "x-baltic",      nsnull };
static nsFontLangGroup FLG_CE      = { "x-central-euro",nsnull };
static nsFontLangGroup FLG_GREEK   = { "el",            nsnull };
static nsFontLangGroup FLG_TURKISH = { "tr",            nsnull };

static void
FreeGlobals(void)
{
  // XXX complete this

  gInitialized = 0;

#ifdef MOZ_ENABLE_FREETYPE2
  nsFT2FontNode::FreeGlobals();
#endif

#ifdef ENABLE_X_FONT_BANNING
  if (gFontRejectRegEx) {
    regfree(gFontRejectRegEx);
    delete gFontRejectRegEx;
    gFontRejectRegEx = nsnull;
  }

      
      FreeGlobals();
      return NS_ERROR_INVALID_ARG;
    }    
  }
#endif /* ENABLE_X_FONT_BANNING */

#ifdef MOZ_ENABLE_FREETYPE2
  rv = nsFT2FontNode::InitGlobals();
  if (NS_FAILED(rv)) {
    FreeGlobals();
    return NS_ERROR_OUT_OF_MEMORY;
  }
#endif

  gInitialized = 1;

  return NS_OK;
}

// do the 8 to 16 bit conversion on the stack

}

void nsFontMetricsGTK::RealizeFont()
{
  float f;
  f = mDeviceContext->DevUnitsToAppUnits();

#ifdef MOZ_ENABLE_FREETYPE2
  if (mWesternFont->IsFreeTypeFont()) {
    nsFreeTypeFont *ft = (nsFreeTypeFont *)mWesternFont;
    if (!ft)
      return;
    // now that there are multiple font types (eg: core X fonts
    // and TrueType fonts) there should be a common set of methods 
    // to get the metrics info from the font object. These methods
    // probably should be virtual functions defined in nsFontGTK.
#if (defined(MOZ_ENABLE_FREETYPE2))
    int lineSpacing = ft->ascent() + ft->descent();
    if (lineSpacing > mWesternFont->mSize) {
      mLeading = nscoord((lineSpacing - mWesternFont->mSize) * f);
    }
    else {
      mLeading = 0;
    }

    }

    /* need better way to calculate this */
    mStrikeoutOffset = NSToCoordRound(mXHeight / 2.0);
    mStrikeoutSize = mUnderlineSize;

    return;
#endif /* (defined(MOZ_ENABLE_FREETYPE2)) */
  }
#endif
  nsXFont *xFont = mWesternFont->GetXFont();
  XFontStruct *fontInfo = xFont->GetXFontStruct();
  f = mDeviceContext->DevUnitsToAppUnits();

  nscoord lineSpacing = nscoord((fontInfo->ascent + fontInfo->descent) * f);
  mEmHeight = PR_MAX(1, nscoord(mWesternFont->mSize * f));
  if (lineSpacing > mEmHeight) {

  return base_aafont;
}

nsFontGTK*
nsFontMetricsGTK::PickASizeAndLoad(nsFontStretch* aStretch,
  nsFontCharSetInfo* aCharSet, PRUint32 aChar, const char *aName)
{

#ifdef MOZ_ENABLE_FREETYPE2
  if (aStretch->mFreeTypeFaceID) {
    //FREETYPE_FONT_PRINTF(("mFreeTypeFaceID = 0x%p", aStretch->mFreeTypeFaceID));
    nsFreeTypeFont *ftfont = nsFreeTypeFont::NewFont(aStretch->mFreeTypeFaceID,
                                                     mPixelSize,
                                                     aName);
    if (!ftfont) {
      FREETYPE_FONT_PRINTF(("failed to create font"));

    return AddToLoadedFontsList(ftfont);
  }

  if (IS_SURROGATE(aChar)) {
    // SURROGATE is only supported by FreeType
    return nsnull;
  }
#endif

  PRBool use_scaled_font = PR_FALSE;
  PRBool have_nearly_rightsized_bitmap = PR_FALSE;
  nsFontGTK* base_aafont = nsnull;

  PRInt32 bitmap_size = NOT_FOUND_FONT_SIZE;
  PRInt32 scale_size = mPixelSize;

{
#ifdef NS_FONT_DEBUG_CALL_TRACE
  if (gFontDebug & NS_FONT_DEBUG_CALL_TRACE) {
    printf("GetFontNames %s\n", aPattern);
  }
#endif

#ifdef MOZ_ENABLE_FREETYPE2
  // get FreeType fonts
  nsFT2FontNode::GetFontNames(aPattern, aNodes);
#endif

  nsCAutoString previousNodeName;
  nsHashtable* node_hash;
  if (aAnyFoundry) {
    NS_ASSERTION(aPattern[1] == '*', "invalid 'anyFoundry' pattern");
    node_hash = gAFRENodes;
  }

    nsFontCharSetMap* charSetMap =
      (nsFontCharSetMap*) gCharSetMaps->Get(&charSetKey);
    if (!charSetMap)
      charSetMap = gNoneCharSetMap;
  return charSetMap;
}

#ifdef MOZ_ENABLE_FREETYPE2
void
CharSetNameToCodeRangeBits(const char *aCharset,
                           PRUint32 *aCodeRange1, PRUint32 *aCodeRange2)
{
  nsFontCharSetMap *charSetMap = GetCharSetMap(aCharset);
  nsFontCharSetInfo* charSetInfo = charSetMap->mInfo;

  *aCodeRange1 = charSetInfo->mCodeRange1Bits;
  *aCodeRange2 = charSetInfo->mCodeRange2Bits;
}
#endif





#include "nsIDeviceContext.h"
#include "nsCRT.h"
#include "nsCOMPtr.h"
#include "nsRenderingContextGTK.h"
#include "nsICharRepresentable.h"
#include "nsCompressedCharMap.h"
#include "nsIFontMetricsGTK.h"
#ifdef MOZ_ENABLE_FREETYPE2
#include "nsIFontCatalogService.h"
#endif

#include <gdk/gdk.h>
#include <gdk/gdkx.h>

#undef FONT_HAS_GLYPH
#define FONT_HAS_GLYPH(map, char) IS_REPRESENTABLE(map, char)
#define WEIGHT_INDEX(weight) (((weight) / 100) - 1)

  nsFontGTK**        mSizes;
  PRUint16           mSizesAlloc;
  PRUint16           mSizesCount;

  char*              mScalable;
  PRBool             mOutlineScaled;
  nsVoidArray        mScaledFonts;
#ifdef MOZ_ENABLE_FREETYPE2
  nsITrueTypeFontCatalogEntry*   mFreeTypeFaceID;
#endif
};

struct nsFontStyle
{
  NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW

  void FillWeightHoles(void);

  NS_DECL_ISUPPORTS
  NS_DECL_NSIFONTENUMERATOR
};

class nsHashKey;
PRBool FreeNode(nsHashKey* aKey, void* aData, void* aClosure);
nsFontCharSetInfo *GetCharSetInfo(const char *aCharSetName);
#ifdef MOZ_ENABLE_FREETYPE2
void CharSetNameToCodeRangeBits(const char*, PRUint32*, PRUint32*);
#endif
nsFontCharSetMap *GetCharSetMap(const char *aCharSetName);




#endif




#include "nsICharsetConverterManager.h"
#include "nsICharRepresentable.h"
#include "nsIPersistentProperties2.h"
#include "nsCompressedCharMap.h"
#include "nsNetUtil.h"
#include "nsClassHashtable.h"
#include "nsAutoBuffer.h"
#include "nsFontConfigUtils.h"

#include <gdk/gdkx.h>
#include <freetype/tttables.h>
#include <freetype/freetype.h>

#define FORCE_PR_LOG
#include "prlog.h"

    // Unicode, Custom, CustomWide
    nsXftFontType               mFontType;
    // Truetype cmap to use for direct retrieval of GIDs with FT_Get_Char_Index
    // for 'narrow' custom fonts.
    FT_Encoding                 mFT_Encoding;
};

struct MozXftLangGroup {
    const char    *mozLangGroup;
    FcChar32       character;
    const FcChar8 *XftLang;
};

static const MozXftLangGroup MozXftLangGroups[] = {
    { "x-western",      0x0041, (const FcChar8 *)"en" },
    { "x-central-euro", 0x0100, (const FcChar8 *)"pl" },
    { "x-cyrillic",     0x0411, (const FcChar8 *)"ru" },
    { "x-baltic",       0x0104, (const FcChar8 *)"lv" },
    { "x-devanagari",   0x0905, (const FcChar8 *)"hi" },
    { "x-tamil",        0x0B85, (const FcChar8 *)"ta" },
    { "x-unicode",      0x0000,                  0    },
    { "x-user-def",     0x0000,                  0    },
};

#define NUM_XFT_LANG_GROUPS (sizeof (MozXftLangGroups) / \
                             sizeof (MozXftLangGroups[0]))

struct DrawStringData {
    nscoord                x;
    nscoord                y;
    const nscoord         *spacing;
    nscoord                xOffset;
    nsRenderingContextGTK *context;
    XftDraw               *draw;

    PRBool firstTime;
};
#endif /* MOZ_MATHML */

#define AUTO_BUFFER_SIZE 3000
typedef nsAutoBuffer<FcChar32, AUTO_BUFFER_SIZE> nsAutoFcChar32Buffer;

static int      CalculateSlant   (PRUint8  aStyle);
static int      CalculateWeight  (PRUint16 aWeight);
static void     AddLangGroup     (FcPattern *aPattern, nsIAtom *aLangGroup);
static void     AddFFRE          (FcPattern *aPattern, nsCString *aFamily,
                                  PRBool aWeak);
static void     FFREToFamily     (nsACString &aFFREName, nsACString &oFamily);
static int      FFRECountHyphens (nsACString &aFFREName);
static int      CompareFontNames (const void* aArg1, const void* aArg2,
                                  void* aClosure);
static PRBool   IsASCIIFontName  (const nsString& aName);
static nsresult EnumFontsXft     (nsIAtom* aLangGroup, const char* aGeneric,
                                  PRUint32* aCount, PRUnichar*** aResult);

static const MozXftLangGroup* FindFCLangGroup (nsACString &aLangGroup);

static        void ConvertCharToUCS4    (const char *aString,
                                         PRUint32 aLength,
                                         nsAutoFcChar32Buffer &aOutBuffer,
                                         PRUint32 *aOutLen);
static        void ConvertUnicharToUCS4 (const PRUnichar *aString,
                                         PRUint32 aLength,
                                         nsAutoFcChar32Buffer &aOutBuffer,

    for (int i=0; i < mFontList.Count(); ++i) {
        // if this was a generic name, break out of the loop since we
        // don't want to add it to the pattern yet
        if (mFontIsGeneric[i])
            break;;

        nsCString *familyName = mFontList.CStringAt(i);
        NS_AddFFRE(mPattern, familyName, PR_FALSE);
    }

    // Add the language group.  Note that we do this before adding any
    // generics.  That's because the language is more important than
    // any generic font.
    NS_AddLangGroup (mPattern, mLangGroup);

    // If there's a generic add a pref for the generic if there's one
    // set.
    if (mGenericFont && !mFont->systemFont) {
        nsCString name;
        name += "font.name.";
        name += mGenericFont->get();

        if (pref) {
            nsresult rv;
            nsXPIDLCString value;
            rv = pref->GetCharPref(name.get(), getter_Copies(value));

            // we ignore prefs that have three hypens since they are X
            // style prefs.
            if (NS_FFRECountHyphens(value) < 3) {
                nsCString tmpstr;
                tmpstr.Append(value);

                if (PR_LOG_TEST(gXftFontLoad, PR_LOG_DEBUG)) {
                    printf("\tadding generic font from preferences: %s\n",
                           tmpstr.get());
                }

                NS_AddFFRE(mPattern, &tmpstr, PR_FALSE);
            }
        }
    }

    // Add the generic if there is one.
    if (mGenericFont && !mFont->systemFont)
        NS_AddFFRE(mPattern, mGenericFont, PR_FALSE);

    if (PR_LOG_TEST(gXftFontLoad, PR_LOG_DEBUG)) {
        // generic font
        if (mGenericFont && !mFont->systemFont) {
            printf("\tadding generic family: %s\n", mGenericFont->get());
        }


        default:
            printf("roman\n");
            break;
        }

        // weight
        printf("\tweight: (orig,calc) %d,%d\n",
               mFont->weight, NS_CalculateWeight(mFont->weight));

    }        

    // add the point size
    // We've done some round-tripping of floating point numbers so they
    // might not be quite right.  Since Xft rounds down, add a little,
    // so we don't go from 9.00000 to 8.99999 to 8.
    FcPatternAddDouble(mPattern, FC_PIXEL_SIZE, mPixelSize + 0.000001);

    // Add the slant type
    FcPatternAddInteger(mPattern, FC_SLANT,
                        NS_CalculateSlant(mFont->style));

    // Add the weight
    FcPatternAddInteger(mPattern, FC_WEIGHT,
                        NS_CalculateWeight(mFont->weight));

    // Set up the default substitutions for this font
    FcConfigSubstitute(0, mPattern, FcMatchPattern);
    XftDefaultSubstitute(GDK_DISPLAY(), DefaultScreen(GDK_DISPLAY()),
                         mPattern);
}


        XftPatternAddBool(mPattern, XFT_RENDER, False);

    FcPatternAddString(pattern, FC_FAMILY, (FcChar8 *)"monospace");

    FcPatternAddInteger(pattern, FC_PIXEL_SIZE, int(0.5 * mPixelSize));

    FcPatternAddInteger(pattern, FC_WEIGHT,
                        NS_CalculateWeight(mFont->weight));

    FcConfigSubstitute(0, pattern, FcMatchPattern);
    XftDefaultSubstitute(GDK_DISPLAY(), DefaultScreen(GDK_DISPLAY()),
                         pattern);

    FcResult res;
    

#endif /* MOZ_MATHML */

/* static */
nsresult
nsFontMetricsXft::FamilyExists(nsIDeviceContext *aDevice,
                               const nsString &aName)
{
    if (!NS_IsASCIIFontName(aName))
        return NS_ERROR_FAILURE;

    NS_ConvertUCS2toUTF8 name(aName);

    FcFontSet *set = nsnull;
    FcObjectSet *os = nsnull;


/* static */
PRBool
nsFontMetricsXft::EnumFontCallback(const nsString &aFamily, PRBool aIsGeneric,
                                   void *aData)
{
    // make sure it's an ascii name, if not then return and continue
    // enumerating
    if (!NS_IsASCIIFontName(aFamily))
        return PR_TRUE;

    nsCAutoString name;
    name.AssignWithConversion(aFamily.get());
    ToLowerCase(name);
    nsFontMetricsXft *metrics = (nsFontMetricsXft *)aData;
    metrics->mFontList.AppendCString(name);

    match_pattern = FcPatternCreate();

  if (!match_pattern)
    return NS_OK; // not fatal, just return an empty default name

  if (aLangGroup && *aLangGroup) {
    nsCOMPtr<nsIAtom> langGroup = do_GetAtom(aLangGroup);
    NS_AddLangGroup(match_pattern, langGroup);
  }

  FcConfigSubstitute(0, match_pattern, FcMatchPattern); 
  FcDefaultSubstitute(match_pattern);
  FcPattern* result_pattern = FcFontMatch(0, match_pattern, &res);
  if (result_pattern) {
    char *family;

    }
}

// Static functions

/* static */
int
CalculateSlant(PRUint8 aStyle)
{
    int fcSlant;

    switch(aStyle) {
    case NS_FONT_STYLE_ITALIC:
        fcSlant = FC_SLANT_ITALIC;
        break;
    case NS_FONT_STYLE_OBLIQUE:
        fcSlant = FC_SLANT_OBLIQUE;
        break;
    default:
        fcSlant = FC_SLANT_ROMAN;
        break;
    }

    return fcSlant;
}

/* static */
int
CalculateWeight (PRUint16 aWeight)
{
    /*
     * weights come in two parts crammed into one
     * integer -- the "base" weight is weight / 100,
     * the rest of the value is the "offset" from that
     * weight -- the number of steps to move to adjust
     * the weight in the list of supported font weights,
     * this value can be negative or positive.
     */
    PRInt32 baseWeight = (aWeight + 50) / 100;
    PRInt32 offset = aWeight - baseWeight * 100;

    /* clip weights to range 0 to 9 */
    if (baseWeight < 0)
        baseWeight = 0;
    if (baseWeight > 9)
        baseWeight = 9;

    /* Map from weight value to fcWeights index */
    static int fcWeightLookup[10] = {
        0, 0, 0, 0, 1, 1, 2, 3, 3, 4,
    };

    PRInt32 fcWeight = fcWeightLookup[baseWeight];

    /*
     * adjust by the offset value, make sure we stay inside the 
     * fcWeights table
     */
    fcWeight += offset;

    if (fcWeight < 0)
        fcWeight = 0;
    if (fcWeight > 4)
        fcWeight = 4;

    /* Map to final FC_WEIGHT value */
    static int fcWeights[5] = {
        FC_WEIGHT_LIGHT,      /* 0 */
        FC_WEIGHT_MEDIUM,     /* 1 */
        FC_WEIGHT_DEMIBOLD,   /* 2 */
        FC_WEIGHT_BOLD,       /* 3 */
        FC_WEIGHT_BLACK,      /* 4 */
    };

    return fcWeights[fcWeight];

}

/* static */
void
AddLangGroup(FcPattern *aPattern, nsIAtom *aLangGroup)
{
    // Find the FC lang group for this lang group
    nsCAutoString cname;
    aLangGroup->ToUTF8String(cname);

    // see if the lang group needs to be translated from mozilla's
    // internal mapping into fontconfig's
    const struct MozXftLangGroup *langGroup;
    langGroup = FindFCLangGroup(cname);

    // if there's no lang group, just use the lang group as it was
    // passed to us
    //
    // we're casting away the const here for the strings - should be
    // safe.
    if (!langGroup)
        FcPatternAddString(aPattern, FC_LANG, (FcChar8 *)cname.get());
    else if (langGroup->XftLang) 
        FcPatternAddString(aPattern, FC_LANG, (FcChar8 *)langGroup->XftLang);
}

/* static */
void
AddFFRE(FcPattern *aPattern, nsCString *aFamily, PRBool aWeak)
{
    nsCAutoString family;
    FFREToFamily(*aFamily, family);

    FcValue v;
    v.type = FcTypeString;
    // casting away the const here, should be safe
    v.u.s = (FcChar8 *)family.get();

    if (aWeak)
        FcPatternAddWeak(aPattern, FC_FAMILY, v, FcTrue);
    else
        FcPatternAdd(aPattern, FC_FAMILY, v, FcTrue);
}

/* static */
void
FFREToFamily(nsACString &aFFREName, nsACString &oFamily)
{
  if (FFRECountHyphens(aFFREName) == 3) {
      PRInt32 familyHyphen = aFFREName.FindChar('-') + 1;
      PRInt32 registryHyphen = aFFREName.FindChar('-',familyHyphen);
      oFamily.Append(Substring(aFFREName, familyHyphen,
                               registryHyphen-familyHyphen));
  }
  else {
      oFamily.Append(aFFREName);
  }
}

/* static */
int
FFRECountHyphens (nsACString &aFFREName)
{
    int h = 0;
    PRInt32 hyphen = 0;
    while ((hyphen = aFFREName.FindChar('-', hyphen)) >= 0) {
        ++h;
        ++hyphen;
    }
    return h;
}

/* static */
int
CompareFontNames (const void* aArg1, const void* aArg2, void* aClosure)
{
    const PRUnichar* str1 = *((const PRUnichar**) aArg1);
    const PRUnichar* str2 = *((const PRUnichar**) aArg2);

    return nsCRT::strcmp(str1, str2);
}

PRBool
IsASCIIFontName(const nsString& aName)
{
    PRUint32 len = aName.Length();
    const PRUnichar* str = aName.get();
    for (PRUint32 i = 0; i < len; i++) {
        /*
         * X font names are printable ASCII, ignore others (for now)
         */
        if ((str[i] < 0x20) || (str[i] > 0x7E)) {
            return PR_FALSE;
        }
    }
  
    return PR_TRUE;
}

/* static */
nsresult
EnumFontsXft(nsIAtom* aLangGroup, const char* aGeneric,
             PRUint32* aCount, PRUnichar*** aResult)
{
    FcPattern   *pat = NULL;
    FcObjectSet *os  = NULL;


    os = FcObjectSetBuild(FC_FAMILY, FC_FOUNDRY, 0);
    if (!os)
        goto end;

    // take the pattern and add the lang group to it
    if (aLangGroup)
        NS_AddLangGroup(pat, aLangGroup);

    // get the font list
    fs = FcFontList(0, pat, os);

    if (!fs)
        goto end;


    if (fs)
        FcFontSetDestroy(fs);

    return rv;
}

/* static */
const MozXftLangGroup*
FindFCLangGroup (nsACString &aLangGroup)
{
    for (unsigned int i=0; i < NUM_XFT_LANG_GROUPS; ++i) {
        if (aLangGroup.Equals(MozXftLangGroups[i].mozLangGroup,
                              nsCaseInsensitiveCStringComparator())) {
            return &MozXftLangGroups[i];
        }
    }

    return nsnull;
}

/* static */
void
ConvertCharToUCS4(const char *aString, PRUint32 aLength, 
                  nsAutoFcChar32Buffer &aOutBuffer, PRUint32 *aOutLen)
{
    *aOutLen = 0;
    FcChar32 *outBuffer;





#endif
#ifdef MOZ_ENABLE_COREXFONTS
#include "nsFontMetricsGTK.h"
#endif
#include "nsFontMetricsUtils.h"
#include "nsPrintSession.h"
#include "gfxImageFrame.h"
#ifdef MOZ_ENABLE_FREETYPE2
#include "nsFT2FontCatalog.h"
#include "nsFreeType.h"
#endif

// objects that just require generic constructors

NS_GENERIC_FACTORY_CONSTRUCTOR(nsDeviceContextGTK)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsRenderingContextGTK)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsImageGTK)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsBlender)

NS_GENERIC_FACTORY_CONSTRUCTOR(nsPrintOptionsGTK)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsPrinterEnumeratorGTK)
#ifdef NATIVE_THEME_SUPPORT
NS_GENERIC_FACTORY_CONSTRUCTOR(nsNativeThemeGTK)
#endif
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsPrintSession, Init)
NS_GENERIC_FACTORY_CONSTRUCTOR(gfxImageFrame)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsFT2FontCatalog)
#ifdef MOZ_ENABLE_FREETYPE2
NS_GENERIC_FACTORY_CONSTRUCTOR(nsFT2FontCatalog)
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsFreeType2, Init)
#endif

// our custom constructors

static nsresult
nsFontMetricsConstructor(nsISupports *aOuter, REFNSIID aIID, void **aResult)

    GFX_IMAGEFRAME_CID,
    "@mozilla.org/gfx/image/frame;2",
    gfxImageFrameConstructor, },
  { "Print Session",
    NS_PRINTSESSION_CID,
    "@mozilla.org/gfx/printsession;1",
    nsPrintSessionConstructor },
#ifdef MOZ_ENABLE_FREETYPE2
  { "TrueType Font Catalog Service",
    NS_FONTCATALOGSERVICE_CID,
    "@mozilla.org/gfx/xfontcatalogservice;1",
    nsFT2FontCatalogConstructor },
#ifdef MOZ_ENABLE_FREETYPE2
  { "FreeType2 routines",
    NS_FREETYPE2_CID,
    NS_FREETYPE2_CONTRACTID,
    nsFreeType2Constructor },
#endif
#ifdef NATIVE_THEME_SUPPORT
   { "Native Theme Renderer",




		-L$(DIST)/lib \
		-lgfxshared_s \
		$(EXTRA_DSO_LIBS) \
		$(MOZ_COMPONENT_LIBS) \
		$(MOZ_UNICHARUTIL_LIBS) \
		$(NULL)

ifdef MOZ_ENABLE_XFT
EXTRA_DSO_LDOPTS += \
		$(MOZ_XFT_LIBS) \
		$(NULL)
endif

ifneq (,$(MOZ_ENABLE_FREETYPE2)$(MOZ_ENABLE_XFT))
CPPSRCS		+= \
		nsCidMap.cpp \
		nsType1.cpp \
		nsType8.cpp \
		$(NULL)
endif

include $(topsrcdir)/config/rules.mk

ifdef MOZ_ENABLE_FREETYPE2
INCLUDES        += $(FT2_CFLAGS)
endif

CFLAGS		+= $(TK_CFLAGS)
CXXFLAGS	+= $(TK_CFLAGS)

LOCAL_INCLUDES = \
		-I../.. \
		-I$(srcdir)/.. \
                 $(NULL)

ifdef MOZ_ENABLE_XFT
INCLUDES		+= $(MOZ_XFT_CFLAGS)
LOCAL_INCLUDES	+= -I$(srcdir)/../shared
else
ifdef MOZ_ENABLE_FREETYPE2
INCLUDES	+= $(FT2_CFLAGS)
endif
endif

libs::
	$(INSTALL) $(EXPORT_RESOURCE) $(DIST)/bin/res

install::
	$(SYSINSTALL) $(IFLAGS1) $(EXPORT_RESOURCE) $(DESTDIR)$(mozappdir)/res





  mParentDeviceContext = aParentContext;

  mPSFontGeneratorList = new nsHashtable();
  NS_ENSURE_TRUE(mPSFontGeneratorList, NS_ERROR_OUT_OF_MEMORY);
 
  nsresult rv;
  nsCOMPtr<nsIPref> pref(do_GetService(NS_PREF_CONTRACTID, &rv));
#ifdef MOZ_ENABLE_XFT
  if (NS_SUCCEEDED(rv)) {
      rv = pref->GetBoolPref("font.FreeType2.printing", &mFTPEnable);
      if (NS_FAILED(rv))
        mFTPEnable = PR_FALSE;
  }
#else 
  mFTPEnable = PR_FALSE;
#ifdef MOZ_ENABLE_FREETYPE2
  if (NS_SUCCEEDED(rv)) {
    rv = pref->GetBoolPref("font.FreeType2.enable", &mFTPEnable);
    if (NS_FAILED(rv))
      mFTPEnable = PR_FALSE;
    if (mFTPEnable) {
      rv = pref->GetBoolPref("font.FreeType2.printing", &mFTPEnable);
      if (NS_FAILED(rv))
        mFTPEnable = PR_FALSE;
    }
  }
#endif
#endif
  
  // the user's locale
  nsCOMPtr<nsILanguageAtomService> langService;
  langService = do_GetService(NS_LANGUAGEATOMSERVICE_CONTRACTID);
  if (langService) {
    langService->GetLocaleLanguageGroup(&gUsersLocale);
  }

 */
NS_IMETHODIMP nsDeviceContextPS::EndDocument(void)
{
  PR_LOG(nsDeviceContextPSLM, PR_LOG_DEBUG, ("nsDeviceContextPS::EndDocument()\n"));

  NS_ENSURE_TRUE(mPSObj != nsnull, NS_ERROR_NULL_POINTER);
  
#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
  // Before output Type8 font, check whether printer support CID font
  if (mFTPEnable && mPSFontGeneratorList)
    if (mPSFontGeneratorList->Count() > 0)
      mPSObj->add_cid_check();
#endif
 
  /* Core of TrueType printing:




 * The Initial Developer of the Original Code is 
 * Netscape Communications Corporation.
 * Portions created by the Initial Developer are Copyright (C) 1998
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>
 *   Ervin Yan <Ervin.Yan@sun.com>
 *   Christopher Blizzard <blizzard@mozilla.org>
 *   Jungshik Shin <jshin@i18nl10n.com>
 *
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only

#include "nsRenderingContextPS.h"
#include "nsIServiceManager.h"
#include "nsGfxCIID.h"

#include "nsIPref.h"
#include "nsVoidArray.h"
#include "nsReadableUtils.h"
#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
#include "nsType8.h"
#endif
#include "prlog.h"

#include "nsArray.h"

extern nsIAtom *gUsersLocale;
#define NS_IS_BOLD(weight) ((weight) > 400 ? 1 : 0)

#ifdef MOZ_ENABLE_XFT

#include "nsFontConfigUtils.h"

static nsFontPS* CreateFontPS(nsXftEntry*, const nsFont&,
                              nsFontMetricsPS*);

#else
#ifdef MOZ_ENABLE_FREETYPE2
static nsFontPS* CreateFontPS(nsITrueTypeFontCatalogEntry*, const nsFont&,
                              nsFontMetricsPS*);

static NS_DEFINE_CID(kFCSCID, NS_FONTCATALOGSERVICE_CID);
#endif
#endif

#ifdef PR_LOGGING
static PRLogModuleInfo *gFontMetricsPSM = PR_NewLogModule("FontMetricsPS");
#endif

/** ---------------------------------------------------
 *  See documentation in nsFontMetricsPS.h

  
  if (mFontsPS) {
    int i;
    for (i=0; i<mFontsPS->Count(); i++) {
      fontps *fontPS = (fontps *)mFontsPS->ElementAt(i);
      if (!fontPS)
        continue;
      NS_IF_RELEASE(fontPS->entry);
      if (fontPS->fontps)
        delete fontPS->fontps;
#ifdef MOZ_ENABLE_XFT
      if (fontPS->entry)
        delete fontPS->entry;
      if (fontPS->charset)
        FcCharSetDestroy(fontPS->charset);
#else
#ifdef MOZ_ENABLE_FREETYPE2
      NS_IF_RELEASE(fontPS->entry);
      if (fontPS->ccmap)
        FreeCCMap(fontPS->ccmap);
#endif
#endif
      delete fontPS;
    }
    delete mFontsPS;
  }

  if (mFontsAlreadyLoaded) {
    delete mFontsAlreadyLoaded;

NS_IMETHODIMP
nsFontMetricsPS :: Init(const nsFont& aFont, nsIAtom* aLangGroup,
  nsIDeviceContext *aContext)
{
  mLangGroup = aLangGroup;

  mFont = new nsFont(aFont);

  //don't addref this to avoid circular refs
  mDeviceContext = (nsDeviceContextPS *)aContext;

  mFontsPS = new nsVoidArray();
  NS_ENSURE_TRUE(mFontsPS, NS_ERROR_OUT_OF_MEMORY);
  mFontsAlreadyLoaded = new nsHashtable();
  NS_ENSURE_TRUE(mFontsAlreadyLoaded, NS_ERROR_OUT_OF_MEMORY);

void
nsFontMetricsPS::RealizeFont()
{
  if (mFont && mDeviceContext) {
    float dev2app;
    dev2app = mDeviceContext->DevUnitsToAppUnits();
    fontps *font = (fontps*)mFontsPS->ElementAt(0);
#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
    NS_ASSERTION(font && font->entry, "no font available");
    if (font && !font->fontps && font->entry)
      font->fontps = CreateFontPS(font->entry, *mFont, this);
#endif
    NS_ASSERTION(font && font->fontps, "no font available");
    if (font && font->fontps)
      font->fontps->RealizeFont(this, dev2app);

// nsFontPS
nsFontPS*
nsFontPS::FindFont(PRUnichar aChar, const nsFont& aFont, 
                   nsFontMetricsPS* aFontMetrics)
{
  nsFontPS* fontPS;

#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
  nsDeviceContextPS* dc = aFontMetrics->GetDeviceContext();
  NS_ENSURE_TRUE(dc, nsnull);
  if (dc->mFTPEnable) {
#ifdef MOZ_ENABLE_XFT
    fontPS = nsFontPSXft::FindFont(aChar, aFont, aFontMetrics);
#else
    fontPS = nsFontPSFreeType::FindFont(aChar, aFont, aFontMetrics);
#endif
    if (fontPS)
      return fontPS;
  }
#endif

  /* Find in afm font */
  if (aFontMetrics->GetFontsPS()->Count() > 0) {

    NS_ENSURE_TRUE(fps, nsnull);
    fontPS = fps->fontps;
  }
  else {
    fontPS = nsFontPSAFM::FindFont(aFont, aFontMetrics);
    fontps *fps = new fontps;
    NS_ENSURE_TRUE(fps, nsnull);
    fps->entry  = nsnull;
    fps->fontps = fontPS;
#if defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_FREETYPE2) 
    fps->entry  = nsnull;
#ifdef MOZ_ENABLE_XFT
    fps->charset = nsnull;
#else
    fps->ccmap  = nsnull;
#endif
#endif
    aFontMetrics->GetFontsPS()->AppendElement(fps);
  }
  return fontPS;
}

nsFontPS::nsFontPS(const nsFont& aFont, nsFontMetricsPS* aFontMetrics)
{

}

nsFontPSAFM::nsFontPSAFM(const nsFont& aFont, nsAFMObject* aAFMInfo,
                         PRInt16 fontIndex, nsFontMetricsPS* aFontMetrics) :
nsFontPS(aFont, aFontMetrics), mAFMInfo(aAFMInfo), mFontIndex(fontIndex)
{
  if (!(mFont && mAFMInfo)) return;
  AppendASCIItoUTF16(mAFMInfo->mPSFontInfo->mFamilyName, mFamilyName);
}

nsFontPSAFM::~nsFontPSAFM()
{
  if (mAFMInfo) {
    delete mAFMInfo;
    mAFMInfo = nsnull;
  }
}

nscoord
nsFontPSAFM::GetWidth(const char* aString, PRUint32 aLength)
{
  nscoord width = 0;
  if (mAFMInfo) {
    mAFMInfo->GetStringWidth(aString, width, aLength);
  }
  return width;
}

nscoord
nsFontPSAFM::GetWidth(const PRUnichar* aString, PRUint32 aLength)
{
  nscoord width = 0;
  if (mAFMInfo) {
    mAFMInfo->GetStringWidth(aString, width, aLength);
  }
  return width;
}

nscoord
nsFontPSAFM::DrawString(nsRenderingContextPS* aContext,
                        nscoord aX, nscoord aY,
                        const char* aString, PRUint32 aLength)
{
  NS_ENSURE_TRUE(aContext, 0);
  nsPostScriptObj* psObj = aContext->GetPostScriptObj();
  NS_ENSURE_TRUE(psObj, 0);

  psObj->moveto(aX, aY);
  psObj->show(aString, aLength, "");
  return GetWidth(aString, aLength);
}

nscoord
nsFontPSAFM::DrawString(nsRenderingContextPS* aContext,
                        nscoord aX, nscoord aY,
                        const PRUnichar* aString, PRUint32 aLength)
{
  NS_ENSURE_TRUE(aContext, 0);
  nsPostScriptObj* psObj = aContext->GetPostScriptObj();
  NS_ENSURE_TRUE(psObj, 0);

  psObj->moveto(aX, aY);
  psObj->show(aString, aLength, "", 0);
  return GetWidth(aString, aLength);
}

nsresult
nsFontPSAFM::RealizeFont(nsFontMetricsPS* aFontMetrics, float dev2app)
{
  NS_ENSURE_ARG_POINTER(aFontMetrics);

  float fontSize;
  float offset;

  nscoord onePixel = NSToCoordRound(1 * dev2app);

  // convert the font size which is in twips to points
  fontSize = mFont->size / TWIPS_PER_POINT_FLOAT;

  offset = NSFloatPointsToTwips(fontSize * mAFMInfo->mPSFontInfo->mXHeight) / 1000.0f;
  nscoord xHeight = NSToCoordRound(offset);
  aFontMetrics->SetXHeight(xHeight);
  aFontMetrics->SetSuperscriptOffset(xHeight);
  aFontMetrics->SetSubscriptOffset(xHeight);
  aFontMetrics->SetStrikeout((nscoord)(xHeight / 2), onePixel);

  offset = NSFloatPointsToTwips(fontSize * mAFMInfo->mPSFontInfo->mUnderlinePosition) / 1000.0f;
  aFontMetrics->SetUnderline(NSToCoordRound(offset), onePixel);

  nscoord size = NSToCoordRound(fontSize * dev2app);
  aFontMetrics->SetHeight(size);
  aFontMetrics->SetEmHeight(size);
  aFontMetrics->SetMaxAdvance(size);
  aFontMetrics->SetMaxHeight(size);

  offset = NSFloatPointsToTwips(fontSize * mAFMInfo->mPSFontInfo->mAscender) / 1000.0f;
  nscoord ascent = NSToCoordRound(offset);
  aFontMetrics->SetAscent(ascent);
  aFontMetrics->SetEmAscent(ascent);
  aFontMetrics->SetMaxAscent(ascent);

  offset = NSFloatPointsToTwips(fontSize * mAFMInfo->mPSFontInfo->mDescender) / 1000.0f;
  nscoord descent = -(NSToCoordRound(offset));
  aFontMetrics->SetDescent(descent);
  aFontMetrics->SetEmDescent(descent);
  aFontMetrics->SetMaxDescent(descent);

  aFontMetrics->SetLeading(0);

  nscoord spaceWidth = GetWidth(" ", 1);
  aFontMetrics->SetSpaceWidth(spaceWidth);

  nscoord aveCharWidth = GetWidth("x", 1);
  aFontMetrics->SetAveCharWidth(aveCharWidth);

  return NS_OK;
}

nsresult
nsFontPSAFM::SetupFont(nsRenderingContextPS* aContext)
{
  NS_ENSURE_TRUE(aContext && mFontMetrics, 0);
  nsPostScriptObj* psObj = aContext->GetPostScriptObj();
  NS_ENSURE_TRUE(psObj, 0);

  nscoord fontHeight = 0;
  mFontMetrics->GetHeight(fontHeight);

  psObj->setscriptfont(mFontIndex, mFamilyName,
                       fontHeight, mFont->style, mFont->variant,
                       mFont->weight, mFont->decorations);
  return NS_OK;
}

#ifdef MOZ_MATHML
nsresult
nsFontPSAFM::GetBoundingMetrics(const char*        aString,
                                PRUint32           aLength,
                                nsBoundingMetrics& aBoundingMetrics)
{
  return NS_ERROR_NOT_IMPLEMENTED;
}

nsresult
nsFontPSAFM::GetBoundingMetrics(const PRUnichar*   aString,
                                PRUint32           aLength,
                                nsBoundingMetrics& aBoundingMetrics)
{
  return NS_ERROR_NOT_IMPLEMENTED;
}
#endif

#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)

#define WIDEN_8_TO_16_BUF_SIZE 1024

#ifdef MOZ_ENABLE_XFT

nsXftEntry::nsXftEntry(FcPattern *aFontPattern)
{
  mFace = nsnull;
  mFaceIndex = 0;

  char *fcResult;

  if (FcPatternGetString(aFontPattern, FC_FILE, 0, (FcChar8 **) &fcResult)
      == FcResultMatch)     
    mFontFileName = fcResult;

  if (FcPatternGetString(aFontPattern, FC_FAMILY, 0, (FcChar8 **) &fcResult)
      == FcResultMatch)     
    mFamilyName = fcResult;

  if (FcPatternGetString(aFontPattern, FC_STYLE, 0, (FcChar8 **) &fcResult)
      == FcResultMatch)
    mStyleName = fcResult;
}


static nsFontPS*
CreateFontPS(nsXftEntry *aEntry, const nsFont& aFont,
             nsFontMetricsPS* aFontMetrics)
{
  nsresult rv;
  nsDeviceContextPS* dc = aFontMetrics->GetDeviceContext();
  NS_ENSURE_TRUE(dc, nsnull);

  nsCAutoString fileName(aEntry->mFontFileName);
  nsCAutoString familyName(aEntry->mFamilyName);
  nsCAutoString styleName(aEntry->mStyleName);
  ToLowerCase(familyName);
  ToLowerCase(styleName);
  
  nsCAutoString fontName;
  fontName.Append(familyName);
  fontName.Append("-");
  fontName.Append(styleName);
  nsCStringKey key(fontName);

  nsHashtable *psFGList = dc->GetPSFontGeneratorList();
  NS_ENSURE_TRUE(psFGList, nsnull);
  
  nsPSFontGenerator* psFontGen = (nsPSFontGenerator*) psFGList->Get(&key);
  if (!psFontGen) {
    psFontGen = new nsXftType8Generator;
    NS_ENSURE_TRUE(psFontGen, nsnull);
    rv = ((nsXftType8Generator*)psFontGen)->Init(aEntry);
    if (NS_FAILED(rv)) {
      delete psFontGen;
      return nsnull;
    }
    psFGList->Put(&key, (void *) psFontGen);
  }
  nsFontPSXft* font = new nsFontPSXft(aFont, aFontMetrics);
  NS_ENSURE_TRUE(font, nsnull);
  rv = font->Init(aEntry, psFontGen);
  if (NS_FAILED(rv)) {
    delete font;
    return nsnull;
  }
  return font;
}

/* static */
PRBool
nsFontPSXft::CSSFontEnumCallback(const nsString& aFamily, PRBool aIsGeneric,
                                      void* aFpi)
{
    fontPSInfo *fpi = (fontPSInfo *)aFpi;

    // make sure it's an ascii name, if not then return and continue
    // enumerating
    if (!NS_IsASCIIFontName(aFamily))
        return PR_TRUE;

    NS_LossyConvertUTF16toASCII name(aFamily);
    ToLowerCase(name);
    fpi->mFontList.AppendCString(name);
    fpi->mFontIsGeneric.AppendElement((void *)aIsGeneric);
    if (aIsGeneric) {
        fpi->mGenericFont =
            fpi->mFontList.CStringAt(fpi->mFontList.Count() - 1);
        return PR_FALSE; // stop processing
    }

    return PR_TRUE; // keep processing
}

nsFontPS*
nsFontPSXft::FindFont(PRUnichar aChar, const nsFont& aFont, 
                           nsFontMetricsPS* aFontMetrics)
{
  PRBool inited = PR_FALSE;
  nsCOMPtr<nsIAtom> langGroup;
  fontPSInfo fpi;
  fpi.fontps = aFontMetrics->GetFontsPS();
  int i = 0;

  while (1) {
    //
    // see if it is already in the list of fonts
    //
    for (; i<fpi.fontps->Count(); i++) {
      fontps *fi = (fontps *)fpi.fontps->ElementAt(i);
      if (!fi->entry || !fi->charset) {
        NS_ASSERTION(fi->entry, "invalid entry");
        NS_ASSERTION(fi->charset, "invalid charset");
        continue;
      }
      if (FcCharSetHasChar(fi->charset, aChar)) {
        if (!fi->fontps) {
#ifdef PR_LOGGING
          if (PR_LOG_TEST(gFontMetricsPSM, PR_LOG_DEBUG)) {
            PR_LogPrint("CreateFontPS %s/%s\n",
                fi->entry->mFamilyName.get(), fi->entry->mStyleName.get());
          }
#endif
          fi->fontps = CreateFontPS(fi->entry, aFont, aFontMetrics);
        }
        if (fi->fontps)
          return fi->fontps;
      }
    }

    // if already get all matched fonts and not found suitable
    // then return nsnull
    if (fpi.fontps->Count() > 0)
      return nsnull;

    //
    // it is not already in the list of fonts
    // so add more fonts to the list
    //
    if (inited)
      return nsnull;
 
    inited = PR_TRUE;

    fpi.nsfont = &aFont;
    fpi.alreadyLoaded = aFontMetrics->GetFontsAlreadyLoadedList();
    fpi.mGenericFont = nsnull;

    aFontMetrics->GetLangGroup(getter_AddRefs(langGroup));
    if (!langGroup)
      langGroup = NS_NewAtom("x-western");

    // enumerate over the font names passed in
    aFont.EnumerateFamilies(nsFontPSXft::CSSFontEnumCallback, &fpi);

    nsCOMPtr<nsIPref> prefService;
    prefService = do_GetService(NS_PREF_CONTRACTID);
    if (!prefService)
      return nsnull;

    nsXPIDLCString value;
    nsCAutoString  aDefaultFont;

    // Set up the default font name if it's not set
    if (!fpi.mGenericFont) {
      prefService->CopyCharPref("font.default", getter_Copies(value));

      if (value.get())
        aDefaultFont = value.get();
      else
        aDefaultFont = "serif";

      fpi.mGenericFont = &aDefaultFont;
    }

    // If pattern is null, set up the base bits of it so we can
    // match.  If we need to match later we don't have to set it up
    // again.
    FcPattern *pattern = nsnull;

    pattern = FcPatternCreate();
    if (!pattern)
      return nsnull;

    // XXX need to add user defined family

    // Add CSS names - walk the list of fonts, adding the generic as
    // the last font
    for (int i=0; i < fpi.mFontList.Count(); ++i) {
      // if this was a generic name, break out of the loop since we
      // don't want to add it to the pattern yet
      if (fpi.mFontIsGeneric[i])
        break;;

      nsCString *familyName = fpi.mFontList.CStringAt(i);
      NS_AddFFRE(pattern, familyName, PR_FALSE);
    }

    // Add the language group.  Note that we do this before adding any
    // generics.  That's because the language is more important than
    // any generic font.
    NS_AddLangGroup(pattern, langGroup);

    // If there's a generic add a pref for the generic if there's one
    // set.
    if (fpi.mGenericFont && !aFont.systemFont) {
      nsCAutoString name("font.name.");
      name += fpi.mGenericFont->get();
      name += ".";

      nsAutoString langGroupStr;
      langGroup->ToString(langGroupStr);

      LossyAppendUTF16toASCII(langGroupStr, name);

      nsCOMPtr<nsIPref> pref;
      pref = do_GetService(NS_PREF_CONTRACTID);
      if (pref) {
        nsresult rv;
        nsXPIDLCString value;
        rv = pref->GetCharPref(name.get(), getter_Copies(value));

        // we ignore prefs that have three hypens since they are X
        // style prefs.
        if (NS_FFRECountHyphens(value) < 3) {
          nsCAutoString tmpstr(value);

          if (PR_LOG_TEST(gFontMetricsPSM, PR_LOG_DEBUG)) {
              printf("\tadding generic font from preferences: %s\n",
                     tmpstr.get());
          }

          NS_AddFFRE(pattern, &tmpstr, PR_FALSE);
        }
      }
    }

    // Add the generic if there is one.
    if (fpi.mGenericFont && !aFont.systemFont)
      NS_AddFFRE(pattern, fpi.mGenericFont, PR_FALSE);

    // Add the slant type
    FcPatternAddInteger(pattern, FC_SLANT, NS_CalculateSlant(aFont.style));

    // Add the weight
    FcPatternAddInteger(pattern, FC_WEIGHT, NS_CalculateWeight(aFont.weight));

    // Set up the default substitutions for this font
    FcConfigSubstitute(0, pattern, FcMatchPattern);
    FcDefaultSubstitute(pattern);

    FcResult   result;
    FcFontSet *set = FcFontSort(0, pattern, FcTrue, 0, &result);
    if (!set) {
       return nsnull;
    }

    // Create a list of new font objects based on the fonts returned
    // as part of the query
    for (int i=0; i < set->nfont; ++i) {
        FcBool fc_outline;
        FcChar8 *fc_family;
        FcChar8 *fc_style;
        FcCharSet *fc_charset;

        // skip if the fonts is not outline font files.
        result = FcPatternGetBool (set->fonts[i], FC_OUTLINE, 0, &fc_outline);
        if (!fc_outline)
          continue;

        result = FcPatternGetString (set->fonts[i], FC_FAMILY, 0, &fc_family);
        if (result != FcResultMatch || fc_family == nsnull)
          continue;

        result = FcPatternGetString (set->fonts[i], FC_STYLE, 0, &fc_style);
        if (result != FcResultMatch || fc_style == nsnull)
          continue;

        result = FcPatternGetCharSet(set->fonts[i], FC_CHARSET, 0, &fc_charset);
        if (result != FcResultMatch || fc_charset == nsnull)
          continue;

        nsXftEntry *xftEntry = new nsXftEntry(set->fonts[i]);
        if (!xftEntry)
          continue;

        fontps *fps = new fontps;
        fps->entry = xftEntry;
        fps->charset = fc_charset;
        fps->fontps = nsnull;
        fpi.fontps->AppendElement(fps);
    }

    // we're done with the set now
    FcFontSetDestroy(set);

    FcPatternDestroy(pattern);
  }

  return nsnull;
}

/*FT_CALLBACK_DEF*/
FT_Error
nsXftFaceRequester(FTC_FaceID face_id, FT_Library lib,
                  FT_Pointer request_data, FT_Face* aFace)
{
  nsXftEntry *faceID = (nsXftEntry *)face_id;

  FT_Error fterror = FT_New_Face(lib, faceID->mFontFileName.get(),
                                 faceID->mFaceIndex, aFace);
  if (fterror) 
    *aFace = nsnull;
  return 0;
}

nsFontPSXft::nsFontPSXft(const nsFont& aFont,
                                   nsFontMetricsPS* aFontMetrics)
  :nsFontPS(aFont, aFontMetrics)
{
}

nsresult
nsFontPSXft::Init(nsXftEntry* aEntry,
                       nsPSFontGenerator* aPSFontGen)
{
  NS_ENSURE_TRUE(aEntry && aPSFontGen, NS_ERROR_FAILURE);
  mEntry = aEntry;
  mPSFontGenerator = aPSFontGen;

  float app2dev;
  nsIDeviceContext* dc = mFontMetrics->GetDeviceContext();
  NS_ENSURE_TRUE(dc, NS_ERROR_NULL_POINTER);
  app2dev = dc->AppUnitsToDevUnits();
  
  mPixelSize = NSToIntRound(app2dev * mFont->size);

  mImageDesc.font.face_id    = (void*)mEntry;
  mImageDesc.font.pix_width  = mPixelSize;
  mImageDesc.font.pix_height = mPixelSize;
  mImageDesc.image_type = 0;

  FT_Error fterror; 
  fterror = FT_Init_FreeType(&mFreeTypeLibrary);
  if (fterror) {
    NS_ASSERTION(!fterror, "failed to initialize FreeType library");
    mFreeTypeLibrary = nsnull;
    return NS_ERROR_FAILURE;
  }
  fterror = FTC_Manager_New(mFreeTypeLibrary, 0, 0, 0, nsXftFaceRequester,
                  NULL, &mFTCacheManager);
  NS_ASSERTION(!fterror, "failed to create FreeType Cache manager");
  if (fterror)
    return NS_ERROR_FAILURE;

  fterror = FTC_Image_Cache_New(mFTCacheManager, &mImageCache);
  NS_ASSERTION(!fterror, "failed to create FreeType image cache");
  if (fterror)
    return NS_ERROR_FAILURE;

  return NS_OK;
}

nsFontPSXft::~nsFontPSXft()
{
  FTC_Manager_Done(mFTCacheManager);

  if (FT_Done_FreeType(mFreeTypeLibrary))
    return;

  mEntry = nsnull;
}

FT_Face
nsFontPSXft::getFTFace()
{
  FT_Error error;
  FT_Face face = mEntry->mFace;

  if (face)
    return (face);

  error = FTC_Manager_Lookup_Size(mFTCacheManager, &mImageDesc.font,
                                  &face, nsnull);
  NS_ASSERTION(error == 0, "failed to get face/size");
  if (error)
    return nsnull;

  mEntry->mFace = face;
  return face;
}

nscoord
nsFontPSXft::GetWidth(const char* aString, PRUint32 aLength)
{
  PRUnichar unichars[WIDEN_8_TO_16_BUF_SIZE];
  PRUint32 len, width = 0;
  while ( aLength > 0 ) {
    len = PR_MIN(aLength, WIDEN_8_TO_16_BUF_SIZE);
    for (PRUint32 i=0; i < len; i++) {
      unichars[i] = PRUnichar(PRUint8(aString[i]));
    }
    width += GetWidth(unichars, len);
    aString += len;
    aLength -= len;
  }
  return width;
}


nscoord
nsFontPSXft::GetWidth(const PRUnichar* aString, PRUint32 aLength)
{
  FT_UInt glyph_index;
  FT_Glyph glyph;
  double origin_x = 0;

  // get the face/size from the FreeType cache
  FT_Face face = getFTFace();
  NS_ASSERTION(face, "failed to get face/size");
  if (!face)
    return 0;

  for (PRUint32 i=0; i<aLength; i++) {
    glyph_index = FT_Get_Char_Index((FT_Face)face, aString[i]);
    FT_Error error = FTC_Image_Cache_Lookup(mImageCache, &mImageDesc,
                                            glyph_index, &glyph);
    if (error) {
      origin_x += FT_REG_TO_16_16(face->size->metrics.x_ppem/2 + 2);
      continue;
    }
    origin_x += glyph->advance.x;
  }

  NS_ENSURE_TRUE(mFontMetrics, 0);

  nsDeviceContextPS* dc = mFontMetrics->GetDeviceContext();
  NS_ENSURE_TRUE(dc, 0);

  float dev2app;
  dev2app = dc->DevUnitsToAppUnits();
  origin_x *= dev2app;
  origin_x /= FT_REG_TO_16_16(1);

  return NSToCoordRound((nscoord)origin_x);
}

nscoord
nsFontPSXft::DrawString(nsRenderingContextPS* aContext,
                             nscoord aX, nscoord aY,
                             const char* aString, PRUint32 aLength)
{
  NS_ENSURE_TRUE(aContext, 0);
  nsPostScriptObj* psObj = aContext->GetPostScriptObj();
  NS_ENSURE_TRUE(psObj, 0);
  nscoord width = 0;
  
  psObj->moveto(aX, aY);

  PRUnichar unichars[WIDEN_8_TO_16_BUF_SIZE];
  PRUint32 len;
  
  while ( aLength > 0 ) {
    len = PR_MIN(aLength, WIDEN_8_TO_16_BUF_SIZE);
    for (PRUint32 i=0; i < len; i++) {
      unichars[i] = PRUnichar(PRUint8(aString[i]));
    }
    psObj->show(unichars, len, "", 1);
    mPSFontGenerator->AddToSubset(unichars, len);
    width += GetWidth(unichars, len);
    aString += len;
    aLength -= len;
  }
  return width;
}

nscoord
nsFontPSXft::DrawString(nsRenderingContextPS* aContext,
                             nscoord aX, nscoord aY,
                             const PRUnichar* aString, PRUint32 aLength)
{
  NS_ENSURE_TRUE(aContext, 0);
  nsPostScriptObj* psObj = aContext->GetPostScriptObj();
  NS_ENSURE_TRUE(psObj, 0);

  psObj->moveto(aX, aY);
  psObj->show(aString, aLength, "", 1);
  
  mPSFontGenerator->AddToSubset(aString, aLength);
  return GetWidth(aString, aLength);
}

int
nsFontPSXft::ascent()
{
  FT_Face face = getFTFace();
  NS_ASSERTION(face, "failed to get face/size");
  NS_ENSURE_TRUE(face, 0);
  return FT_DESIGN_UNITS_TO_PIXELS(face->ascender, face->size->metrics.y_scale);
}

int
nsFontPSXft::descent()
{
  FT_Face face = getFTFace();
  NS_ASSERTION(face, "failed to get face/size");
  NS_ENSURE_TRUE(face, 0);
  return FT_DESIGN_UNITS_TO_PIXELS(-face->descender, face->size->metrics.y_scale);
}

int
nsFontPSXft::max_ascent()
{
  FT_Face face = getFTFace();
  NS_ASSERTION(face, "failed to get face/size");
  NS_ENSURE_TRUE(face, 0);
  TT_OS2 *tt_os2 = (TT_OS2 *) FT_Get_Sfnt_Table(face, ft_sfnt_os2);
  NS_ASSERTION(tt_os2, "unable to get OS2 table");
  if (tt_os2)
     return FT_DESIGN_UNITS_TO_PIXELS(tt_os2->sTypoAscender,
                                      face->size->metrics.y_scale);
  else
     return FT_DESIGN_UNITS_TO_PIXELS(face->bbox.yMax,
                                      face->size->metrics.y_scale);
}

int
nsFontPSXft::max_descent()
{
  FT_Face face = getFTFace();
  NS_ASSERTION(face, "failed to get face/size");
  NS_ENSURE_TRUE(face, 0);
  TT_OS2 *tt_os2 = (TT_OS2 *) FT_Get_Sfnt_Table(face, ft_sfnt_os2);
  NS_ASSERTION(tt_os2, "unable to get OS2 table");
  if (tt_os2)
     return FT_DESIGN_UNITS_TO_PIXELS(-tt_os2->sTypoDescender,
                                      face->size->metrics.y_scale);
  else
     return FT_DESIGN_UNITS_TO_PIXELS(-face->bbox.yMin,
                                      face->size->metrics.y_scale);
}

int
nsFontPSXft::max_width()
{
  FT_Face face = getFTFace();
  NS_ASSERTION(face, "failed to get face/size");
  NS_ENSURE_TRUE(face, 0);
  return FT_DESIGN_UNITS_TO_PIXELS(face->max_advance_width,
                                   face->size->metrics.x_scale);
}

PRBool
nsFontPSXft::getXHeight(unsigned long &aVal)
{
  FT_Face face = getFTFace();
  NS_ASSERTION(face, "failed to get face/size");
  if (!face || !aVal)
    return PR_FALSE;
  aVal = FT_DESIGN_UNITS_TO_PIXELS(face->height, face->size->metrics.y_scale);

  return PR_TRUE;
}

PRBool
nsFontPSXft::underlinePosition(long &aVal)
{
  FT_Face face = getFTFace();
  NS_ASSERTION(face, "failed to get face/size");
  if (!face)
    return PR_FALSE;
  aVal = FT_DESIGN_UNITS_TO_PIXELS(-face->underline_position,
                                   face->size->metrics.y_scale);
  return PR_TRUE;
}

PRBool
nsFontPSXft::underline_thickness(unsigned long &aVal)
{
  FT_Face face = getFTFace();
  NS_ASSERTION(face, "failed to get face/size");
  if (!face)
    return PR_FALSE;
  aVal = FT_DESIGN_UNITS_TO_PIXELS(face->underline_thickness,
                                   face->size->metrics.x_scale);
  return PR_TRUE;
}

PRBool
nsFontPSXft::superscript_y(long &aVal)
                        nscoord aX, nscoord aY,
                        const char* aString, PRUint32 aLength)
{
  aVal = 0;
  FT_Face face = getFTFace();
  NS_ASSERTION(face, "failed to get face/size");
  if (!face)
    return PR_FALSE;

  TT_OS2 *tt_os2 = (TT_OS2 *) FT_Get_Sfnt_Table(face, ft_sfnt_os2);
  NS_ASSERTION(tt_os2, "unable to get OS2 table");
  if (!tt_os2)
    return PR_FALSE;

  aVal = FT_DESIGN_UNITS_TO_PIXELS(tt_os2->ySuperscriptYOffset,
                                  face->size->metrics.y_scale);
  return PR_TRUE;
}

PRBool
nsFontPSXft::subscript_y(long &aVal)
                        nscoord aX, nscoord aY,
                        const PRUnichar* aString, PRUint32 aLength)
{
  aVal = 0;
  FT_Face face = getFTFace();
  NS_ASSERTION(face, "failed to get face/size");
  if (!face)
    return PR_FALSE;

  TT_OS2 *tt_os2 = (TT_OS2 *) FT_Get_Sfnt_Table(face, ft_sfnt_os2);
  NS_ASSERTION(tt_os2, "unable to get OS2 table");
  if (!tt_os2)
    return PR_FALSE;

  aVal = FT_DESIGN_UNITS_TO_PIXELS(tt_os2->ySubscriptYOffset,
                                  face->size->metrics.y_scale);

  // some fonts have the sign wrong. it should be always positive.
  aVal = (aVal < 0) ? -aVal : aVal;
  return PR_TRUE;
}

nsresult
nsFontPSXft::RealizeFont(nsFontMetricsPS* aFontMetrics, float dev2app)
{
 
  nscoord leading, emHeight, emAscent, emDescent;
  nscoord maxHeight, maxAscent, maxDescent, maxAdvance;
  nscoord xHeight, spaceWidth, aveCharWidth;
  nscoord underlineOffset, underlineSize, superscriptOffset, subscriptOffset;
  nscoord strikeoutOffset, strikeoutSize;

  int lineSpacing = ascent() + descent();
  if (lineSpacing > mPixelSize) {
    leading = nscoord((lineSpacing - mPixelSize) * dev2app);
  }
  else {
    leading = 0;
  }
  emHeight = PR_MAX(1, nscoord(mPixelSize * dev2app));
  emAscent = nscoord(ascent() * mPixelSize * dev2app / lineSpacing);
  emDescent = emHeight - emAscent;

  maxHeight  = nscoord((max_ascent() + max_descent()) * dev2app);
  maxAscent  = nscoord(max_ascent() * dev2app) ;
  maxDescent = nscoord(max_descent() * dev2app);
  maxAdvance = nscoord(max_width() * dev2app);

  // 56% of ascent, best guess for non-true type
  xHeight = NSToCoordRound((float)ascent()* dev2app * 0.56f);
  aFontMetrics->SetXHeight(xHeight);
  aFontMetrics->SetSuperscriptOffset(xHeight);
  aFontMetrics->SetSubscriptOffset(xHeight);
  aFontMetrics->SetStrikeout((nscoord)(xHeight / 2), onePixel);

  PRUnichar space = (PRUnichar)' ';
  spaceWidth = NSToCoordRound(GetWidth(&space, 1));
  PRUnichar averageX = (PRUnichar)'x';
  aveCharWidth = NSToCoordRound(GetWidth(&averageX, 1));
  
  unsigned long pr = 0;
  if (getXHeight(pr)) {
    xHeight = (nscoord(pr * dev2app));
  }

  float height;
  long val;
  
  height = ascent() + descent();
  underlineOffset = -NSToIntRound(
                    PR_MAX (1, floor (0.1 * height + 0.5)) * dev2app);

  if (underline_thickness(pr)) {
    /* this will only be provided from adobe .afm fonts */
    underlineSize = nscoord(PR_MAX(dev2app, NSToIntRound(pr * dev2app)));
  }
  else {
    height = ascent() + descent();
    underlineSize = NSToIntRound(
                    PR_MAX(1, floor (0.05 * height + 0.5)) * dev2app);
  }

  if (superscript_y(val)) {
    superscriptOffset = nscoord(PR_MAX(dev2app, NSToIntRound(val * dev2app)));
  }
  else {
    superscriptOffset = xHeight;
  }

  if (subscript_y(val)) {
    subscriptOffset = nscoord(PR_MAX(dev2app, NSToIntRound(val * dev2app)));
  }
  else {
   subscriptOffset = xHeight;
  }

  /* need better way to calculate this */
  strikeoutOffset = NSToCoordRound(xHeight / 2.0);
  strikeoutSize = underlineSize;
  
  // TODO: leading never used, does it equal to "Height"?
  aFontMetrics->SetHeight(emHeight);
  aFontMetrics->SetEmHeight(emHeight);
  aFontMetrics->SetEmAscent(emAscent);
  aFontMetrics->SetEmDescent(emDescent);
  aFontMetrics->SetMaxHeight(maxHeight);
  aFontMetrics->SetMaxAscent(maxAscent);
  aFontMetrics->SetMaxDescent(maxDescent);
  aFontMetrics->SetMaxAdvance(maxAdvance);
  aFontMetrics->SetXHeight(xHeight);
  aFontMetrics->SetSpaceWidth(spaceWidth);

  nscoord aveCharWidth = GetWidth("x", 1);
  aFontMetrics->SetAveCharWidth(aveCharWidth);
  aFontMetrics->SetUnderline(underlineOffset, underlineSize);
  aFontMetrics->SetSuperscriptOffset(superscriptOffset);
  aFontMetrics->SetSubscriptOffset(subscriptOffset);
  aFontMetrics->SetStrikeout(strikeoutOffset, strikeoutSize);

  return NS_OK;
}

nsresult
nsFontPSXft::SetupFont(nsRenderingContextPS* aContext)
{
  NS_ENSURE_TRUE(aContext, NS_ERROR_FAILURE);
  nsPostScriptObj* psObj = aContext->GetPostScriptObj();
  NS_ENSURE_TRUE(psObj, NS_ERROR_FAILURE);

  nscoord fontHeight = 0;
  mFontMetrics->GetHeight(fontHeight);

  nsCString fontName;
  int wmode = 0;
  FT_Face face = getFTFace();
  NS_ENSURE_TRUE(face, NS_ERROR_NULL_POINTER);
  char *cidFontName = FT2ToType8CidFontName(face, wmode);
  NS_ENSURE_TRUE(cidFontName, NS_ERROR_FAILURE);
  fontName.Assign(cidFontName);
  psObj->setfont(fontName, fontHeight);
  PR_Free(cidFontName);
  
  return NS_OK;
}

#ifdef MOZ_MATHML
nsresult
nsFontPSXft::GetBoundingMetrics(const char*        aString,
                                     PRUint32           aLength,
                                     nsBoundingMetrics& aBoundingMetrics)
{
  return NS_ERROR_NOT_IMPLEMENTED;
}

nsresult
nsFontPSXft::GetBoundingMetrics(const PRUnichar*   aString,
                                     PRUint32           aLength,
                                     nsBoundingMetrics& aBoundingMetrics)
{
  return NS_ERROR_NOT_IMPLEMENTED;
}
#endif //MOZ_MATHML

#ifdef MOZ_ENABLE_FREETYPE2

#else

PRBool
nsFontPSFreeType::CSSFontEnumCallback(const nsString& aFamily, PRBool aGeneric,
                                      void* aFpi)
{
  fontPSInfo* fpi = (fontPSInfo*)aFpi;
  nsCAutoString familyname;

      return PR_TRUE; // keep trying
    }
    nsXPIDLCString value;
    nsresult rv;
    nsCOMPtr<nsIPref> pref(do_GetService(NS_PREF_CONTRACTID, &rv));
    NS_ENSURE_SUCCESS(rv, PR_TRUE); // keep trying
    nsCAutoString name("font.name.");
    LossyAppendUTF16toASCII(aFamily, name);
    name.Append(char('.'));
    name.Append(fpi->lang);
    pref->CopyCharPref(name.get(), getter_Copies(value));
    if (!value.get())
      return PR_TRUE; // keep trying
    // strip down to just the family name
    PRInt32 startFamily = value.FindChar('-') + 1;

      else  // FFRE 
        familyname.Append(Substring(value, startFamily, endFamily - startFamily));
    }
    PR_LOG(gFontMetricsPSM, PR_LOG_DEBUG,
        ("generic font \"%s\" -> \"%s\"\n", name.get(), familyname.get()));
  }
  else
    LossyAppendUTF16toASCII(aFamily, familyname);

  AddFontEntries(familyname, fpi->lang, fpi->weight, 
                 nsIFontCatalogService::kFCWidthAny, fpi->slant,
                 nsIFontCatalogService::kFCSpacingAny, fpi);

  return PR_TRUE;
}

                                     nsBoundingMetrics& aBoundingMetrics)
{
  return NS_ERROR_NOT_IMPLEMENTED;
}
#endif //MOZ_MATHML

#endif //MOZ_ENABLE_FREETYPE2
#endif //MOZ_ENABLE_XFT

// Implementation of nsPSFontGenerator
nsPSFontGenerator::nsPSFontGenerator()
{
}

nsPSFontGenerator::~nsPSFontGenerator()

  for (PRUint32 i=0; i < aLength; i++) {
    unichar = (PRUnichar)((unsigned char)aString[i]);
    if (mSubset.FindChar(unichar) == -1 )
      mSubset.Append(unichar);
  }
}

#ifdef MOZ_ENABLE_XFT
nsXftType8Generator::nsXftType8Generator()
{
}

nsresult
nsXftType8Generator::Init(nsXftEntry* aEntry)
{
  NS_ENSURE_TRUE(aEntry, NS_ERROR_FAILURE);
  mEntry = aEntry;

  FT_Error error = FT_Init_FreeType(&mFreeTypeLibrary);
  NS_ASSERTION(!error, "failed to initialize FreeType library");
  if (error) {
    mFreeTypeLibrary = nsnull;
    return NS_ERROR_FAILURE;
  }
  error = FTC_Manager_New(mFreeTypeLibrary, 0, 0, 0, nsXftFaceRequester,
                          NULL, &mFTCacheManager);
  NS_ASSERTION(!error, "failed to create FreeType Cache manager");
  if (error)
    return NS_ERROR_FAILURE;

  return NS_OK;
}

nsXftType8Generator::~nsXftType8Generator()
{
  FTC_Manager_Done(mFTCacheManager);

  if (FT_Done_FreeType(mFreeTypeLibrary))
    return;

  mEntry = nsnull;
}

void nsXftType8Generator::GeneratePSFont(FILE* aFile)
{
  FT_Error error;
  FT_Face face = mEntry->mFace;

  if (face == nsnull) {
    mImageDesc.font.face_id    = (void*)mEntry;
    mImageDesc.font.pix_width  = 16;
    mImageDesc.font.pix_height = 16;
    mImageDesc.image_type = 0;
    error = FTC_Manager_Lookup_Size(mFTCacheManager, &mImageDesc.font,
                                    &face, nsnull);
    if (error)
      return;
  }

  if (face == nsnull)
    return;
 
  int wmode = 0;
  if (!mSubset.IsEmpty())
    FT2SubsetToType8(face, mSubset.get(), mSubset.Length(), wmode, aFile);
}

#else
#ifdef MOZ_ENABLE_FREETYPE2

nsFT2Type8Generator::nsFT2Type8Generator()
{
}

nsresult
nsFT2Type8Generator::Init(nsITrueTypeFontCatalogEntry* aEntry)
{

  if (NS_FAILED(rv))
    return;
 
  int wmode = 0;
  if (!mSubset.IsEmpty())
    FT2SubsetToType8(face, mSubset.get(), mSubset.Length(), wmode, aFile);
}
#endif //MOZ_ENABLE_FREETYPE2

#endif //MOZ_ENABLE_FREETYPE2
#endif //MOZ_ENABLE_XFT




#include "nsIAtom.h"
#include "nsUnitConversion.h"
#include "nsIDeviceContext.h"
#include "nsCOMPtr.h"
#include "nsCRT.h"
#include "nsCompressedCharMap.h"
#include "nsPostScriptObj.h"
#ifdef MOZ_ENABLE_XFT
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_GLYPH_H
#include FT_CACHE_H
#include FT_CACHE_IMAGE_H
#include FT_OUTLINE_H
#include FT_OUTLINE_H
#include FT_TRUETYPE_TABLES_H
#else
#ifdef MOZ_ENABLE_FREETYPE2
#include "nsIFontCatalogService.h"
#endif
#endif
#include "nsVoidArray.h"
#include "nsHashtable.h"

class nsPSFontGenerator;
class nsDeviceContextPS;
class nsRenderingContextPS;
class nsFontPS;

#endif

  nsAFMObject* mAFMInfo;
  PRInt16      mFontIndex;
  nsString     mFamilyName;
};


#ifdef MOZ_ENABLE_XFT

#include <X11/Xft/Xft.h>

class nsXftEntry
{
public:
  nsXftEntry(FcPattern *aFontPattern);
  ~nsXftEntry() {}; 

  FT_Face       mFace;
  int           mFaceIndex;
  nsCString     mFontFileName;
  nsCString     mFamilyName;
  nsCString     mStyleName;

protected:
  nsXftEntry() {};
};

struct fontps {
  nsXftEntry *entry;
  nsFontPS   *fontps;
  FcCharSet  *charset;
};

struct fontPSInfo {
  nsVoidArray     *fontps;
  const nsFont*    nsfont;
  nsCAutoString    lang;
  nsHashtable     *alreadyLoaded;
  nsCStringArray   mFontList;
  nsAutoVoidArray  mFontIsGeneric;
  nsCString       *mGenericFont;
};

class nsFontPSXft : public nsFontPS
{
public:
  static nsFontPS* FindFont(PRUnichar aChar, const nsFont& aFont,
                            nsFontMetricsPS* aFontMetrics);
  nsresult         Init(nsXftEntry* aEntry,
                        nsPSFontGenerator* aPSFontGen);
  static PRBool CSSFontEnumCallback(const nsString& aFamily, PRBool aGeneric,
                                    void* aFpi);

  nsFontPSXft(const nsFont& aFont, nsFontMetricsPS* aFontMetrics);
  virtual ~nsFontPSXft();
  NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW

  nscoord GetWidth(const char* aString, PRUint32 aLength);
  nscoord GetWidth(const PRUnichar* aString, PRUint32 aLength);
  nscoord DrawString(nsRenderingContextPS* aContext,
                     nscoord aX, nscoord aY,
                     const char* aString, PRUint32 aLength);
  nscoord DrawString(nsRenderingContextPS* aContext,
                     nscoord aX, nscoord aY,
                     const PRUnichar* aString, PRUint32 aLength);
  nsresult RealizeFont(nsFontMetricsPS* aFontMetrics, float dev2app);
  nsresult SetupFont(nsRenderingContextPS* aContext);

#ifdef MOZ_MATHML
  nsresult
  GetBoundingMetrics(const char*        aString,
                     PRUint32           aLength,
                     nsBoundingMetrics& aBoundingMetrics);
  nsresult
  GetBoundingMetrics(const PRUnichar*   aString,
                     PRUint32           aLength,
                     nsBoundingMetrics& aBoundingMetrics);
#endif

  nsXftEntry *mEntry;
  FT_Face getFTFace();

protected:
  PRUint16        mPixelSize;
  FTC_Image_Desc  mImageDesc;
  FT_Library      mFreeTypeLibrary;
  FTC_Manager     mFTCacheManager;
  FTC_Image_Cache mImageCache;

  int     ascent();
  int     descent();
  PRBool  getXHeight(unsigned long &aVal);
  int     max_ascent();
  int     max_descent();
  int     max_width();
  PRBool  superscript_y(long &aVal);
  PRBool  subscript_y(long &aVal);
  PRBool  underlinePosition(long &aVal);
  PRBool  underline_thickness(unsigned long &aVal);
  nsPSFontGenerator*  mPSFontGenerator;
};

#else

#ifdef MOZ_ENABLE_FREETYPE2
#include "nsIFreeType2.h"

typedef struct {
  nsITrueTypeFontCatalogEntry *entry;
  nsFontPS *fontps;
  unsigned short *ccmap;
} fontps;

#ifdef MOZ_ENABLE_FREETYPE2

#include "nsIFreeType2.h"

typedef struct {
  nsVoidArray *fontps;
  const nsFont* nsfont;
  nsCAutoString lang;
  nsHashtable *alreadyLoaded;
  PRUint16 slant;
  PRUint16 weight;

  PRBool  superscript_y(long &aVal);
  PRBool  subscript_y(long &aVal);
  PRBool  underlinePosition(long &aVal);
  PRBool  underline_thickness(unsigned long &aVal);
  nsPSFontGenerator*  mPSFontGenerator;
};

#else // !FREETYPE2 && !XFT
typedef struct {
  nsFontPS   *fontps;
} fontps;
#endif // MOZ_ENABLE_FREETYPE2
#endif   // MOZ_ENABLE_XFT

class nsPSFontGenerator {
public:
  nsPSFontGenerator();
  virtual ~nsPSFontGenerator();
  virtual void  GeneratePSFont(FILE* aFile);
  void  AddToSubset(const PRUnichar* aString, PRUint32 aLength);
  void  AddToSubset(const char* aString, PRUint32 aLength);

protected:
  nsString mSubset;
};


#ifdef MOZ_ENABLE_XFT

class nsXftType8Generator : public nsPSFontGenerator {
public:
  nsXftType8Generator();
  ~nsXftType8Generator();
  nsresult Init(nsXftEntry* aFce);
  void  GeneratePSFont(FILE* aFile);

protected:
  nsXftEntry *mEntry;
  FTC_Image_Desc  mImageDesc;
  FT_Library      mFreeTypeLibrary;
  FTC_Manager     mFTCacheManager;
};
#else
#ifdef MOZ_ENABLE_FREETYPE2
class nsFT2Type8Generator : public nsPSFontGenerator {
public:
  nsFT2Type8Generator();
  ~nsFT2Type8Generator();
  nsresult Init(nsITrueTypeFontCatalogEntry* aFce);
  void  GeneratePSFont(FILE* aFile);

protected:
  nsCOMPtr<nsITrueTypeFontCatalogEntry> mEntry;
  nsCOMPtr<nsIFreeType2> mFt2;
  FTC_Image_Desc  mImageDesc;
};
#endif   // MOZ_ENABLE_FREETYPE2
#endif   // MOZ_ENABLE_XFT

#endif






#include "nsType1.h"

static const PRUint16 type1_encryption_c1 = TYPE1_ENCRYPTION_C1;
static const PRUint16 type1_encryption_c2 = TYPE1_ENCRYPTION_C2;

typedef struct {
#ifndef MOZ_ENABLE_XFT
  nsIFreeType2  *ft2;
#endif
  FT_Face        face;
  int            elm_cnt;
  int            len;
  double         cur_x;
  double         cur_y;
  unsigned char *buf;
  int            wmode;

{
  int aw = 0;
  int ah = 0;
  FT_UShort upm = aFti->face->units_per_EM;
  FT_GlyphSlot slot;
  FT_Glyph glyph;
  FT_BBox bbox;
  nsresult rv;

  slot = aFti->face->glyph;

#ifdef MOZ_ENABLE_XFT
  FT_Error error = FT_Get_Glyph(slot, &glyph);
  if (error) {
    NS_ERROR("sideWidthAndBearing failed to get glyph");
    return PR_FALSE;
  }
  FT_Glyph_Get_CBox(glyph, ft_glyph_bbox_unscaled, &bbox);
#else
  nsresult rv = aFti->ft2->GetGlyph(slot, &glyph);
  if (NS_FAILED(rv)) {
    NS_ERROR("sideWidthAndBearing failed to get glyph");
    return PR_FALSE;
  }
  aFti->ft2->GlyphGetCBox(glyph, ft_glyph_bbox_unscaled, &bbox);
#endif

  if (aFti->wmode == 0)
    aw = toCS(upm, slot->metrics.horiAdvance);
  else
    aw = -toCS(upm, slot->metrics.vertAdvance);

  if (aEndPt->y == 0) {

  conicto,
  cubicto,
  0,
  0
};

FT_Error
#ifdef MOZ_ENABLE_XFT
FT2GlyphToType1CharString(FT_Face aFace, PRUint32 aGlyphID,
                          int aWmode, int aLenIV, unsigned char *aBuf)
#else
FT2GlyphToType1CharString(nsIFreeType2 *aFt2, FT_Face aFace, PRUint32 aGlyphID,
                          int aWmode, int aLenIV, unsigned char *aBuf)
#endif
{
  int j;
  FT_Int32 flags = FT_LOAD_NO_BITMAP | FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
  FT_GlyphSlot slot;
  unsigned char *start = aBuf;
  FT2PT1_info fti;
  nsresult rv;

#ifdef MOZ_ENABLE_XFT
  FT_Error error = FT_Load_Glyph(aFace, aGlyphID, flags);
  if (error) {
    NS_ERROR("failed to load aGlyphID");
    return error;
  }
#else
  nsresult rv = aFt2->LoadGlyph(aFace, aGlyphID, flags);
  if (NS_FAILED(rv)) {
    NS_ERROR("failed to load aGlyphID");
    return 1;
  }
#endif
  slot = aFace->glyph;

  if (slot->format != ft_glyph_format_outline) {
    NS_ERROR("aGlyphID is not an outline glyph");
    return 1;
  }

#ifndef MOZ_ENABLE_XFT
  fti.ft2     = aFt2;
#endif
  fti.face    = aFace;
  fti.buf     = aBuf;
  fti.elm_cnt = 0;
  fti.len     = 0;
  fti.wmode   = aWmode;

  /* add space for "random" bytes */
  for (j=0; j< aLenIV; j++) {
    fti.len += ecsi(&fti.buf, 0);
  }
#ifdef MOZ_ENABLE_XFT
  if (FT_Outline_Decompose(&slot->outline, &ft_outline_funcs, &fti))  {
    NS_ERROR("error decomposing aGlyphID");
    return 1;
  }
#else
  rv = aFt2->OutlineDecompose(&slot->outline, &ft_outline_funcs, &fti);
  if (NS_FAILED(rv)) {
    NS_ERROR("error decomposing aGlyphID");
    return 1;
  }
#endif

  if (fti.elm_cnt) {
    fti.len += csc(&fti.buf, T1_CLOSEPATH);
    fti.len += csc(&fti.buf, T1_ENDCHAR);
  }
  else {
    FT_Vector end_pt;




//

#ifndef TYPE1_H
#define TYPE1_H

#include <stdio.h>
#include "nspr.h"
#ifdef MOZ_ENABLE_XFT
#include "nsISupports.h"
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_GLYPH_H
#include FT_OUTLINE_H
#else
#include "nsIFreeType2.h"
#endif

/* to/from Character Space */
inline int
toCS(double upm, double x)
{
  return (int)((x*1000.0)/upm);
}

/* the 2 byte (escaped) Postscript Type 1 commands */
#define T1_ESC_SBW    7  /* 0x07 */

#define TYPE1_ENCRYPTION_KEY 4330
#define TYPE1_ENCRYPTION_C1  52845
#define TYPE1_ENCRYPTION_C2  22719

#ifdef MOZ_ENABLE_XFT  
FT_Error FT2GlyphToType1CharString(FT_Face aFace,
#else /* MOZ_ENABLE_FREETYPE2 */
FT_Error FT2GlyphToType1CharString(nsIFreeType2 *aFt2, FT_Face aFace,
#endif
                                   PRUint32 aGlyphID, int aWmode, int aLenIV,
                                   unsigned char *aBuf);

#endif /* TYPE1_H */





#include <string.h>
#include <unistd.h>

#include "nsCidMap.h"
#include "nsType1.h"
#include "nsType8.h"
#ifndef MOZ_ENABLE_XFT
#include "nsIFreeType2.h"
#endif
#include "nsIServiceManager.h"
#include "nsISignatureVerifier.h"
#include "plbase64.h"
#include "nsCRT.h"

#define DEFAULT_CMAP_SIZE 10240

#define HEXASCII_LINE_LEN 64


static void hex_out(unsigned char *buf, PRUint32 n, FILE *f, PRUint32 *pos);

static void flatten_name(char *aToName);
#ifdef MOZ_ENABLE_XFT
static int FT2SubsetToCidKeyedType1(FT_Face aFace,
#else
static int FT2SubsetToCidKeyedType1(nsIFreeType2 *aFt2, FT_Face aFace,
#endif
                                    const PRUnichar *aCharIDs, int aLen,
                                    const char *aFontName,
                                    const char *aRegistry,
                                    const char *aEncoding, int aSupplement,
                                    int aWmode, int aLenIV, FILE *aFile);

void

  char *encoding = NULL;
  int supplement, lenIV;
  PRUint32 CIDs_buf[5000];
  PRUint32 *CIDs = CIDs_buf;
  int cmap_type = 0;
  PRBool status = PR_FALSE;

#ifndef MOZ_ENABLE_XFT
  nsresult rv;
  nsCOMPtr<nsIFreeType2> ft2 = do_GetService(NS_FREETYPE2_CONTRACTID, &rv);
  if (NS_FAILED(rv)) {
    NS_ERROR("Failed to get nsIFreeType2 service");
    goto done;
  }
#endif

  if ((aNumChars+1) > sizeof(CIDs_buf)/sizeof(CIDs_buf[0]))
    CIDs = (PRUint32 *)PR_Malloc((aNumChars+1)*sizeof(CIDs_buf[0]));
  if (!CIDs) {
    NS_ERROR("Failed to alloc space for CIDs");
    goto done;
  }

  WriteCmapHeader(cmapname, registry, encoding, supplement, cmap_type, aWmode,
                  aFile);
  WriteCodeSpaceRangeMapUCS2(aFile);
  WriteCidCharMap(aCharIDs, CIDs, aNumChars, aFile);
  WriteCmapFooter(aFile);

  /* output the Type 8 CID font */
#ifdef MOZ_ENABLE_XFT
  FT2SubsetToCidKeyedType1(aFace, aCharIDs, aNumChars, fontname,
#else
  FT2SubsetToCidKeyedType1(ft2, aFace, aCharIDs, aNumChars, fontname,
#endif
                           registry, encoding, supplement, aWmode, lenIV,
                           aFile);
  fprintf(aFile, "\n");

  /* compose the cmap and font */
  fprintf(aFile, "/%s\n", cidfontname);
  fprintf(aFile, "  /%s /CMap findresource\n", cmapname);

  PR_FREEIF(cidfontname);
  if (CIDs != CIDs_buf)
    PR_Free(CIDs);
  return status;
}

static PRBool
#ifdef MOZ_ENABLE_XFT
FT2SubsetToCidKeyedType1(FT_Face aFace,
#else
FT2SubsetToCidKeyedType1(nsIFreeType2 *aFt2, FT_Face aFace,
#endif
                         const PRUnichar *aCharIDs,
                         int aLen, const char *aFontName,
                         const char *aRegistry, const char *aEncoding,
                         int aSupplement, int aWmode, int aLenIV, FILE *aFile)
{
  int i, charstrings_len, data_offset;
  unsigned int charstring_len;

                 toCS(upm, aFace->bbox.yMin),
                 toCS(upm, aFace->bbox.xMax),
                 toCS(upm, aFace->bbox.yMax));

  fprintf(aFile, "\n");

  /* measure the notdef glyph length */
#ifdef MOZ_ENABLE_XFT
  cmapinfo[0] = FT2GlyphToType1CharString(aFace, 0, aWmode, aLenIV, NULL);
#else
  cmapinfo[0] = FT2GlyphToType1CharString(aFt2, aFace, 0, aWmode, aLenIV, NULL);
#endif
  num_charstrings = 1;
  charstrings_len = cmapinfo[0];

  /* get charstring lengths */
  max_charstring = cmapinfo[0];
  for (i=0; i<aLen; i++) {
#ifdef MOZ_ENABLE_XFT
    glyphID = FT_Get_Char_Index(aFace, aCharIDs[i]);
    cmapinfo[i+1] = FT2GlyphToType1CharString(aFace, glyphID, aWmode,
                                              aLenIV, NULL);
#else
    aFt2->GetCharIndex(aFace, aCharIDs[i], &glyphID);
    cmapinfo[i+1] = FT2GlyphToType1CharString(aFt2, aFace, glyphID, aWmode,
                                              aLenIV, NULL);
#endif
    charstrings_len += cmapinfo[i+1];
    if (cmapinfo[i+1])
      num_charstrings++;
    if (cmapinfo[i+1] > max_charstring)
      max_charstring = cmapinfo[i+1];
  }
  cmapinfo[i+1] = 0;

    data_offset += cmapinfo[i];
  }

  //
  // output the charStrings
  //
  // output the notdef glyph
#ifdef MOZ_ENABLE_XFT
  charstring_len = FT2GlyphToType1CharString(aFace, 0, aWmode, aLenIV,
                                             charstring);
#else
  charstring_len = FT2GlyphToType1CharString(aFt2, aFace, 0, aWmode, aLenIV,
                                             charstring);
#endif
  hex_out(charstring, charstring_len, aFile, &line_pos);

  /* output the charstrings for the glyphs */
  for (i=0; i<aLen; i++) {
#ifdef MOZ_ENABLE_XFT
    glyphID = FT_Get_Char_Index(aFace, aCharIDs[i]);
    charstring_len = FT2GlyphToType1CharString(aFace, glyphID, aWmode,
                                               aLenIV, charstring);
#else
    aFt2->GetCharIndex(aFace, aCharIDs[i], &glyphID);
    charstring_len = FT2GlyphToType1CharString(aFt2, aFace, glyphID, aWmode,
                                               aLenIV, charstring);
#endif
    NS_ASSERTION(charstring_len==cmapinfo[i+1], "glyph data changed");
    hex_out(charstring, charstring_len, aFile, &line_pos);
  }
  // add one byte padding so the interperter can always do 2 byte reads
  charstring[0] = 0;
  hex_out(charstring, 1, aFile, &line_pos);





 * ***** END LICENSE BLOCK ***** */

#ifndef TYPE8_H
#define TYPE8_H

#include <stdio.h>
#include "nspr.h"
#ifdef MOZ_ENABLE_XFT
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_GLYPH_H
#include FT_CACHE_H
#include FT_CACHE_IMAGE_H
#include FT_OUTLINE_H
// macros to handle FreeType2 26.6 numbers (26 bit number with 6 bit fraction)
#define FT_REG_TO_16_16(x) ((x)<<16)
#ifndef FT_MulFix
#define FT_MulFix(v, s) (((v)*(s))>>16)
#endif
#define FT_ROUND(x) (((x) + 32) & ~63) // 63 = 2^6 - 1
#define FT_TRUNC(x) ((x) >> 6)
#define FT_DESIGN_UNITS_TO_PIXELS(v, s) FT_TRUNC(FT_ROUND(FT_MulFix((v) , (s))))
#else /* MOZ_ENABLE_FREETYPE2 */
#include "nsIFreeType2.h"
#endif /* MOZ_ENABLE_XFT */

void AddCIDCheckCode(FILE *aFile);
PRBool FT2SubsetToType8(FT_Face aFace, const PRUnichar *aCharIDs,
                        PRUint32 aNumChars, int aWmode, FILE *aFile);
char*  FT2ToType8CidFontName(FT_Face aFace, int aWmode);






                fflush(stdout); \
              } \
            PR_END_MACRO

#define FREETYPE_FONT_PRINTF(x) \
         DEBUG_PRINTF_MACRO(x, NS_FONT_DEBUG_FREETYPE_FONT)

#ifdef MOZ_ENABLE_FREETYPE2
extern PRUint32 gFontDebug;
#endif

#endif





#include "nsCOMPtr.h"
#include "nsPrintfCString.h"
#include "nspr.h"
#include "nsHashtable.h"
#include "nsReadableUtils.h"
#include "nsAString.h"
#include "nsXPIDLString.h"
#ifdef MOZ_ENABLE_FREETYPE2
#include "nsFT2FontCatalog.h"
#include "nsFreeType.h"
#endif /* MOZ_ENABLE_FREETYPE2 */
#ifdef USE_X11SHARED_CODE
#include "nsXFontNormal.h"
#endif /* USE_X11SHARED_CODE */
#ifdef USE_AASB
#include "nsX11AlphaBlend.h"
#include "nsXFontAAScaledBitmap.h"
#endif /* USE_AASB */

#define FONT_MAX_FONT_SCALE 2

#undef NOISY_FONTS
#undef REALLY_NOISY_FONTS

/* Local prototypes */
static PRBool                 FreeNode(nsHashKey* aKey, void* aData, void* aClosure);
#ifdef MOZ_ENABLE_FREETYPE2
static void                   CharSetNameToCodeRangeBits(const char*, PRUint32*, PRUint32*);
#endif /* MOZ_ENABLE_FREETYPE2 */
static const nsFontCharSetMapXlib *GetCharSetMap(nsFontMetricsXlibContext *aFmctx, const char *aCharSetName);

// the font catalog is so expensive to generate
// always tell the user what is happening
static PRUint32 gFontDebug = 0 | NS_FONT_DEBUG_FONT_SCAN;

struct nsFontCharSetMapXlib;

  double                                mBitmapUndersize;

#ifdef USE_AASB
  PRInt32                               mAntiAliasMinimum;
#endif /* USE_AASB */
  PRInt32                               mEmbeddedBitmapMaximumHeight;

#ifdef MOZ_ENABLE_FREETYPE2
  PRBool                                mEnableFreeType2;
  PRBool                                mFreeType2Autohinted;
  PRBool                                mFreeType2Unhinted;
#endif /* MOZ_ENABLE_FREETYPE2 */
#ifdef USE_AASB
  PRUint8                               mAATTDarkTextMinValue;
  double                                mAATTDarkTextGain;
#endif /* USE_AASB */

#ifdef ENABLE_X_FONT_BANNING
  regex_t                              *mFontRejectRegEx,

};

struct nsFontCharSetInfoXlib
{
  const char*            mCharSet;
  nsFontCharSetConverterXlib Convert;
  PRUint8                mSpecialUnderline;
#ifdef MOZ_ENABLE_FREETYPE2
  PRInt32                mCodeRange1Bits;
  PRInt32                mCodeRange2Bits;
#endif
  PRUint16*              mCCMap;
  nsIUnicodeEncoder*     mConverter;
  nsIAtom*               mLangGroup;
  PRBool                 mInitedSizeInfo;
  PRInt32                mOutlineScaleMin;
  PRInt32                mBitmapScaleMin;
  double                 mBitmapOversize;

  const PRUnichar* aSrcBuf, PRInt32 aSrcLen, char* aDestBuf, PRInt32 aDestLen);
static int ISO10646Convert(nsFontCharSetInfoXlib* aSelf, XFontStruct* aFont,
  const PRUnichar* aSrcBuf, PRInt32 aSrcLen, char* aDestBuf, PRInt32 aDestLen);

static nsFontCharSetInfoXlib Unknown = { nsnull };
static nsFontCharSetInfoXlib Special = { nsnull };

#ifdef MOZ_ENABLE_FREETYPE2
static nsFontCharSetInfoXlib USASCII =
  { "us-ascii", SingleByteConvert, 0,
    TT_OS2_CPR1_LATIN1 | TT_OS2_CPR1_MAC_ROMAN,
    TT_OS2_CPR2_CA_FRENCH |  TT_OS2_CPR2_PORTUGESE
    | TT_OS2_CPR2_WE_LATIN1 |  TT_OS2_CPR2_US };
static nsFontCharSetInfoXlib ISO88591 =
  { "ISO-8859-1", SingleByteConvert, 0,

   { "x-mathematica2", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};
static nsFontCharSetInfoXlib Mathematica3 =
   { "x-mathematica3", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};
static nsFontCharSetInfoXlib Mathematica4 =
   { "x-mathematica4", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};
static nsFontCharSetInfoXlib Mathematica5 =
   { "x-mathematica5", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};
#endif /* MATHML */

#else

static nsFontCharSetInfoXlib USASCII =
  { "us-ascii", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib ISO88591 =
  { "ISO-8859-1", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib ISO88592 =
  { "ISO-8859-2", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib ISO88593 =
  { "ISO-8859-3", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib ISO88594 =
  { "ISO-8859-4", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib ISO88595 =
  { "ISO-8859-5", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib ISO88596 =
  { "ISO-8859-6", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib ISO885968x =
  { "x-iso-8859-6-8-x", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib ISO8859616 =
  { "x-iso-8859-6-16", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib IBM1046 =
  { "x-IBM1046", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib ISO88597 =
  { "ISO-8859-7", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib ISO88598 =
  { "ISO-8859-8", SingleByteConvert, 0 };
// change from  
// { "ISO-8859-8", SingleByteConvertReverse, 0, 0, 0 };
// untill we fix the layout and ensure we only call this with pure RTL text
static nsFontCharSetInfoXlib ISO88599 =
  { "ISO-8859-9", SingleByteConvert, 0 };
// no support for iso-8859-10 (Nordic/Icelandic) currently
// static nsFontCharSetInfoXlib ISO885910 =
// { "ISO-8859-10", SingleByteConvert, 0,
//   0, TT_OS2_CPR2_NORDIC | TT_OS2_CPR2_ICELANDIC };
// no support for iso-8859-12 (Vietnamese) currently
// static nsFontCharSetInfoXlib ISO885912 =
// { "ISO-8859-12", SingleByteConvert, 0,
//   TT_OS2_CPR1_VIETNAMESE, 0 };
static nsFontCharSetInfoXlib ISO885913 =
  { "ISO-8859-13", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib ISO885915 =
  { "ISO-8859-15", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib JISX0201 =
  { "jis_0201", SingleByteConvert, 1 };
static nsFontCharSetInfoXlib KOI8R =
  { "KOI8-R", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib KOI8U =
  { "KOI8-U", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib TIS6202 =
/* Added to support thai context sensitive shaping if
 * CTL extension is is in force */
#ifdef SUNCTL
  { "tis620-2", SingleByteConvert, 0 };
#else
  { "windows-874", SingleByteConvert, 0 };
#endif /* SUNCTL */
static nsFontCharSetInfoXlib TIS620 =
  { "TIS-620", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib ISO885911 =
  { "ISO-8859-11", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib Big5 =
  { "x-x-big5", DoubleByteConvert, 1 };
// a kludge to distinguish zh-TW only fonts in Big5 (such as hpbig5-)
// from zh-TW/zh-HK common fonts in Big5 (such as big5-1)
static nsFontCharSetInfoXlib Big5TWHK =
  { "x-x-big5", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib CNS116431 =
  { "x-cns-11643-1", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib CNS116432 =
  { "x-cns-11643-2", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib CNS116433 =
  { "x-cns-11643-3", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib CNS116434 =
  { "x-cns-11643-4", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib CNS116435 =
  { "x-cns-11643-5", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib CNS116436 =
  { "x-cns-11643-6", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib CNS116437 =
  { "x-cns-11643-7", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib GB2312 =
  { "gb_2312-80", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib GB18030_0 =
  { "gb18030.2000-0", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib GB18030_1 =
  { "gb18030.2000-1", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib GBK =
  { "x-gbk-noascii", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib HKSCS =
  { "hkscs-1", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib JISX0208 =
  { "jis_0208-1983", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib JISX0212 =
  { "jis_0212-1990", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib KSC5601 =
  { "ks_c_5601-1987", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib X11Johab =
  { "x-x11johab", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib JohabNoAscii =
  { "x-johab-noascii", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib JamoTTF =
  { "x-koreanjamo-0", DoubleByteConvert, 1 };
static nsFontCharSetInfoXlib TamilTTF =
  { "x-tamilttf-0", DoubleByteConvert, 0 };
static nsFontCharSetInfoXlib CP1250 =
  { "windows-1250", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib CP1251 =
  { "windows-1251", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib CP1252 =
  { "windows-1252", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib CP1253 =
  { "windows-1253", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib CP1257 =
  { "windows-1257", SingleByteConvert, 0 };

#ifdef SUNCTL
/* Hindi range currently unsupported in FT2 range. Change TT* once we 
   arrive at a way to identify hindi */
static nsFontCharSetInfoXlib SunIndic =
  { "x-sun-unicode-india-0", DoubleByteConvert, 0 };
#endif /* SUNCTL */

static nsFontCharSetInfoXlib ISO106461 =
  { nsnull, ISO10646Convert, 1};

static nsFontCharSetInfoXlib AdobeSymbol =
   { "Adobe-Symbol-Encoding", SingleByteConvert, 0 };
static nsFontCharSetInfoXlib AdobeEuro =
  { "x-adobe-euro", SingleByteConvert, 0 };
         
#ifdef MOZ_MATHML
static nsFontCharSetInfoXlib CMCMEX =
   { "x-t1-cmex", SingleByteConvert, 0};
static nsFontCharSetInfoXlib CMCMSY =
   { "x-t1-cmsy", SingleByteConvert, 0};
static nsFontCharSetInfoXlib CMCMR =
   { "x-t1-cmr", SingleByteConvert, 0};
static nsFontCharSetInfoXlib CMCMMI =
   { "x-t1-cmmi", SingleByteConvert, 0};
static nsFontCharSetInfoXlib Mathematica1 =
   { "x-mathematica1", SingleByteConvert, 0};
static nsFontCharSetInfoXlib Mathematica2 =
   { "x-mathematica2", SingleByteConvert, 0}; 
static nsFontCharSetInfoXlib Mathematica3 =
   { "x-mathematica3", SingleByteConvert, 0};
static nsFontCharSetInfoXlib Mathematica4 =
   { "x-mathematica4", SingleByteConvert, 0}; 
static nsFontCharSetInfoXlib Mathematica5 =
   { "x-mathematica5", SingleByteConvert, 0};
#endif /* MATHML */
#endif /* FREETYPE2 */

static nsFontLangGroupXlib FLG_WESTERN = { "x-western",     nsnull };
static nsFontLangGroupXlib FLG_BALTIC  = { "x-baltic",      nsnull };
static nsFontLangGroupXlib FLG_CE      = { "x-central-euro",nsnull };
static nsFontLangGroupXlib FLG_RUSSIAN = { "x-cyrillic",    nsnull };
static nsFontLangGroupXlib FLG_GREEK   = { "el",            nsnull };
static nsFontLangGroupXlib FLG_TURKISH = { "tr",            nsnull };

/* This is only required for the main display */
static nsFontMetricsXlibContext *global_fmctx = nsnull;

nsFontMetricsXlibContext::~nsFontMetricsXlibContext()
{
  PR_LOG(FontMetricsXlibLM, PR_LOG_DEBUG, ("# nsFontMetricsXlibContext destroy()\n"));

#ifdef MOZ_ENABLE_FREETYPE2
  nsFreeTypeFreeGlobals();
#endif /* MOZ_ENABLE_FREETYPE2 */

#ifdef ENABLE_X_FONT_BANNING
  if (mFontRejectRegEx) {
    regfree(mFontRejectRegEx);
    delete mFontRejectRegEx;
  }
  

  mBitmapUndersize = 0.8;

#ifdef USE_AASB
  mAntiAliasMinimum = 8;
#endif /* USE_AASB */
  mEmbeddedBitmapMaximumHeight = 1000000;

#ifdef MOZ_ENABLE_FREETYPE2
  mEnableFreeType2 = PR_TRUE;
  mFreeType2Autohinted = PR_FALSE;
  mFreeType2Unhinted = PR_TRUE;
#endif /* MOZ_ENABLE_FREETYPE2 */
#ifdef USE_AASB
  mAATTDarkTextMinValue = 64;
  mAATTDarkTextGain = 0.8;
#endif /* USE_AASB */

#ifdef ENABLE_X_FONT_BANNING
  mFontRejectRegEx = nsnull;

#ifdef USE_XPRINT
  }
#endif /* USE_XPRINT */
  if (NS_SUCCEEDED(rv)) {
    mForceOutlineScaledFonts = force_outline_scaled_fonts;
  }

#ifdef MOZ_ENABLE_FREETYPE2
  PRBool enable_freetype2 = PR_TRUE;
  rv = mPref->GetBoolPref("font.FreeType2.enable", &enable_freetype2);
  if (NS_SUCCEEDED(rv)) {
    mEnableFreeType2 = enable_freetype2;
    FREETYPE_FONT_PRINTF(("mEnableFreeType2 = %d", mEnableFreeType2));
  }



  PRBool freetype2_unhinted = PR_TRUE;
  rv = mPref->GetBoolPref("font.FreeType2.unhinted", &freetype2_unhinted);
  if (NS_SUCCEEDED(rv)) {
    mFreeType2Unhinted = freetype2_unhinted;
    FREETYPE_FONT_PRINTF(("mFreeType2Unhinted = %d", mFreeType2Unhinted));
  }
#endif /* MOZ_ENABLE_FREETYPE2 */

#ifdef USE_AASB
  PRInt32 antialias_minimum = 8;
  rv = mPref->GetIntPref("font.antialias.min", &antialias_minimum);
  if (NS_SUCCEEDED(rv)) {
    mAntiAliasMinimum = antialias_minimum;
    FREETYPE_FONT_PRINTF(("mAntiAliasMinimum = %d", mAntiAliasMinimum));

      mFontAcceptRegEx = nsnull;
      
      return NS_ERROR_INVALID_ARG;
    }    
  }
#endif /* ENABLE_X_FONT_BANNING */

#ifdef MOZ_ENABLE_FREETYPE2
  rv = nsFreeTypeInitGlobals();
  if (NS_FAILED(rv)) {
    return NS_ERROR_OUT_OF_MEMORY;
  }
#endif /* MOZ_ENABLE_FREETYPE2 */

  return NS_OK;
}

#ifdef USE_X11SHARED_CODE
#error not implemented yet
#else

}

void nsFontMetricsXlib::RealizeFont()
{
  float f;
  f = mDeviceContext->DevUnitsToAppUnits();

#ifdef MOZ_ENABLE_FREETYPE2
  if (mWesternFont->IsFreeTypeFont()) {
    nsFreeTypeFont *ft = (nsFreeTypeFont *)mWesternFont;
    if (!ft)
      return;
    // now that there are multiple font types (eg: core X fonts
    // and TrueType fonts) there should be a common set of methods 
    // to get the metrics info from the font object. These methods

    /* need better way to calculate this */
    mStrikeoutOffset = NSToCoordRound(mXHeight / 2.0);
    mStrikeoutSize = mUnderlineSize;

    return;
#endif /* MOZ_ENABLE_FREETYPE2 */
  }
#endif /* MOZ_ENABLE_FREETYPE2 */
  nsXFont *xFont = mWesternFont->GetXFont();
  XFontStruct *fontInfo = xFont->GetXFontStruct();
  f = mDeviceContext->DevUnitsToAppUnits();

  nscoord lineSpacing = nscoord((fontInfo->ascent + fontInfo->descent) * f);
  mEmHeight = PR_MAX(1, nscoord(mWesternFont->mSize * f));
  if (lineSpacing > mEmHeight) {


PRBool
nsFontXlib::GetXFontIs10646(void)
{
  return ((PRBool) (mCharSetInfo == mFontMetricsContext->mISO106461));
}

#ifdef MOZ_ENABLE_FREETYPE2
PRBool
nsFontXlib::IsFreeTypeFont(void)
{
  return PR_FALSE;
}
#endif /* MOZ_ENABLE_FREETYPE2 */

MOZ_DECL_CTOR_COUNTER(nsFontXlib)

nsFontXlib::nsFontXlib()
{
  MOZ_COUNT_CTOR(nsFontXlib);
}

}
#endif /* USE_AASB */

nsFontXlib*
nsFontMetricsXlib::PickASizeAndLoad(nsFontStretchXlib* aStretch,
  nsFontCharSetInfoXlib* aCharSet, PRUnichar aChar, const char *aName)
{
#ifdef MOZ_ENABLE_FREETYPE2
  if (aStretch->mFreeTypeFaceID) {
    //FREETYPE_FONT_PRINTF(("mFreeTypeFaceID = 0x%p", aStretch->mFreeTypeFaceID));
    nsFreeTypeFont *ftfont = nsFreeTypeFont::NewFont(aStretch->mFreeTypeFaceID,
                                                     mPixelSize,
                                                     aName);
    if (!ftfont) {
      FREETYPE_FONT_PRINTF(("failed to create font"));

    SetCharsetLangGroup(mFontMetricsContext, aCharSet);
    ftfont->mSize = mPixelSize;
    ftfont->LoadFont();
    ftfont->mCharSetInfo = mFontMetricsContext->mISO106461;
    //FREETYPE_FONT_PRINTF(("add the ftfont"));
    return AddToLoadedFontsList(ftfont);
  }
#endif /* MOZ_ENABLE_FREETYPE2 */

  PRBool      use_scaled_font               = PR_FALSE;
  PRBool      have_nearly_rightsized_bitmap = PR_FALSE;
#ifdef USE_AASB
  nsFontXlib *base_aafont                   = nsnull;
#endif /* USE_AASB */



#ifdef NS_FONT_DEBUG_CALL_TRACE
  if (gFontDebug & NS_FONT_DEBUG_CALL_TRACE) {
    printf("GetFontNames %s\n", aPattern);
  }
#endif

#ifdef MOZ_ENABLE_FREETYPE2
  // get FreeType fonts
  nsFT2FontCatalog::GetFontNames(aFmctx, aPattern, aNodes);
#endif /* MOZ_ENABLE_FREETYPE2 */

  nsCAutoString previousNodeName;
  nsHashtable* node_hash;
  if (aAnyFoundry) {
    NS_ASSERTION(aPattern[1] == '*', "invalid 'anyFoundry' pattern");
    node_hash = &aFmctx->mAFRENodes;
  }

  nsCStringKey charSetKey(aCharSetName);
  const nsFontCharSetMapXlib* charSetMap = (const nsFontCharSetMapXlib *) aFmctx->mCharSetMaps.Get(&charSetKey);
  if (!charSetMap)
    charSetMap = aFmctx->mNoneCharSetMap;
  return charSetMap;
}

#ifdef MOZ_ENABLE_FREETYPE2
static
void CharSetNameToCodeRangeBits(const char *aCharset,
                                PRUint32 *aCodeRange1, PRUint32 *aCodeRange2)
{
  nsFontCharSetMapXlib  *charSetMap  = GetCharSetMap(aFmctx, aCharset);
  nsFontCharSetInfoXlib *charSetInfo = charSetMap->mInfo;

  *aCodeRange1 = charSetInfo->mCodeRange1Bits;
  *aCodeRange2 = charSetInfo->mCodeRange2Bits;
}
#endif /* MOZ_ENABLE_FREETYPE2 */





#include "nsCRT.h"
#include "nsCOMPtr.h"
#include "nsRenderingContextXlib.h"
#include "nsICharRepresentable.h"
#include "nsCompressedCharMap.h"

/* Undefine some CPP symbols which wrap not-yet-implemented code */
#undef MOZ_ENABLE_FREETYPE2
#undef USE_AASB
#undef USE_X11SHARED_CODE

#ifdef USE_X11SHARED_CODE
/* XXX: I wish I would use the code in gfx/src/x11shared/ - unfortunately
 * it is full of GDK/GTK+ dependices which makes it impossible to use it
 * yet... ;-(

struct nsFontFamilyXlib;
struct nsFontNodeXlib;
struct nsFontStretchXlib;
struct nsFontWeightXlib;

class nsFontXlibUserDefined;
class nsFontMetricsXlib;
#ifdef MOZ_ENABLE_FREETYPE2
class nsFreeTypeFace;
#endif /* MOZ_ENABLE_FREETYPE2 */

struct nsFontStretchXlib
{
  NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW

  void SortSizes(void);

  nsFontXlib       **mSizes;
  PRUint16           mSizesAlloc;
  PRUint16           mSizesCount;

  char*              mScalable;
  PRBool             mOutlineScaled;
  nsVoidArray        mScaledFonts;
#ifdef MOZ_ENABLE_FREETYPE2
  nsFreeTypeFace    *mFreeTypeFaceID;
#endif /* MOZ_ENABLE_FREETYPE2 */
};

struct nsFontStyleXlib
{
  NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW

  void FillWeightHoles(void);


  inline int SupportsChar(PRUnichar aChar)
    { return mCCMap && CCMAP_HAS_CHAR(mCCMap, aChar); };

  virtual XFontStruct *GetXFontStruct(void);
  virtual nsXFont     *GetXFont(void);
  virtual PRBool       GetXFontIs10646(void);
#ifdef MOZ_ENABLE_FREETYPE2
  virtual PRBool       IsFreeTypeFont(void);
#endif /* MOZ_ENABLE_FREETYPE2 */
  virtual int          GetWidth(const PRUnichar* aString, PRUint32 aLength) = 0;
  virtual int          DrawString(nsRenderingContextXlib *aContext,
                                  nsIDrawingSurfaceXlib *aSurface, nscoord aX,
                                  nscoord aY, const PRUnichar* aString,
                                  PRUint32 aLength) = 0;
#ifdef MOZ_MATHML
  // bounding metrics for a string 


class nsHashKey;

/* XXX: We can't include gfx/src/x11shared/nsFreeType.h because it relies on
 * GDK/GTK+ includes which are not available in Xlib builds (fix is to remove
 * the GDK/GTK+ dependicy from the code in gfx/src/x11shared/ ...)
 */
#ifndef MOZ_ENABLE_FREETYPE2
/*
 * Defines for the TrueType codepage bits.
 * Used as a hint for the languages supported in a TrueType font.
 */

/*
 * ulCodePageRange1

#define TT_OS2_CPR2_CYRILLIC     (0x02000000)/*IBM Cyrillic; primarily Russian*/
#define TT_OS2_CPR2_LATIN2       (0x04000000) /* Latin 2                     */
#define TT_OS2_CPR2_BALTIC       (0x08000000) /* MS-DOS Baltic               */
#define TT_OS2_CPR2_GREEK_437G   (0x10000000) /* Greek; former 437 G         */
#define TT_OS2_CPR2_ARABIC_708   (0x20000000) /* Arabic; ASMO 708            */
#define TT_OS2_CPR2_WE_LATIN1    (0x40000000) /* WE/Latin 1                  */
#define TT_OS2_CPR2_US           (0x80000000) /* US                          */
#endif /* !MOZ_ENABLE_FREETYPE2 */

#endif /* !nsFontMetricsXlib_h__ */


Lines 50-59 CPPSRCS = \ Link Here

(-)gfx/src/shared/Makefile.in (+5 lines)
50		50
51	ifneq (,$(filter mac cocoa,$(MOZ_WIDGET_TOOLKIT)))	51	ifneq (,$(filter mac cocoa,$(MOZ_WIDGET_TOOLKIT)))
52	CPPSRCS += nsNativeTheme.cpp	52	CPPSRCS += nsNativeTheme.cpp
53	endif	53	endif
54		54
55	LOCAL_INCLUDES = -I$(srcdir)/.. \	55	LOCAL_INCLUDES = -I$(srcdir)/.. \
56	$(NULL)	56	$(NULL)
		57
		58	ifdef MOZ_ENABLE_XFT
		59	CPPSRCS += nsFontConfigUtils.cpp
		60	LOCAL_INCLUDES += $(MOZ_XFT_CFLAGS)
		61	endif
57		62
58	include $(topsrcdir)/config/rules.mk	63	include $(topsrcdir)/config/rules.mk
59		64




/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is mozilla.org code.
 *
 * The Initial Developer of the Original Code is Christopher Blizzard
 * <blizzard@mozilla.org>.  Portions created by the Initial Developer
 * are Copyright (C) 2002 the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either of the GNU General Public License Version 2 or later (the "GPL"),
 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "nsFontConfigUtils.h"

struct MozXftLangGroup {
    const char    *mozLangGroup;
    FcChar32       character;
    const FcChar8 *XftLang;
};

const MozXftLangGroup MozXftLangGroups[] = {
    { "x-western",      0x0041, (const FcChar8 *)"en" },
    { "x-central-euro", 0x0100, (const FcChar8 *)"pl" },
    { "x-cyrillic",     0x0411, (const FcChar8 *)"ru" },
    { "x-baltic",       0x0104, (const FcChar8 *)"lv" },
    { "x-devanagari",   0x0905, (const FcChar8 *)"hi" },
    { "x-tamil",        0x0B85, (const FcChar8 *)"ta" },
    { "x-unicode",      0x0000,                  0    },
    { "x-user-def",     0x0000,                  0    },
};

#define NUM_XFT_LANG_GROUPS (sizeof (MozXftLangGroups) / \
                             sizeof (MozXftLangGroups[0]))

static 
void FFREToFamily(nsACString &aFFREName, nsACString &oFamily);

static
const MozXftLangGroup*
FindFCLangGroup (nsACString &aLangGroup)
{
    for (unsigned int i=0; i < NUM_XFT_LANG_GROUPS; ++i) {
        if (aLangGroup.Equals(MozXftLangGroups[i].mozLangGroup,
                              nsCaseInsensitiveCStringComparator())) {
            return &MozXftLangGroups[i];
        }
    }

    return nsnull;
}

int
NS_CalculateSlant(PRUint8 aStyle)
{
    int fcSlant;

    switch(aStyle) {
    case NS_FONT_STYLE_ITALIC:
        fcSlant = FC_SLANT_ITALIC;
        break;
    case NS_FONT_STYLE_OBLIQUE:
        fcSlant = FC_SLANT_OBLIQUE;
        break;
    default:
        fcSlant = FC_SLANT_ROMAN;
        break;
    }

    return fcSlant;
}

int
NS_CalculateWeight (PRUint16 aWeight)
{
    /*
     * weights come in two parts crammed into one
     * integer -- the "base" weight is weight / 100,
     * the rest of the value is the "offset" from that
     * weight -- the number of steps to move to adjust
     * the weight in the list of supported font weights,
     * this value can be negative or positive.
     */
    PRInt32 baseWeight = (aWeight + 50) / 100;
    PRInt32 offset = aWeight - baseWeight * 100;

    /* clip weights to range 0 to 9 */
    if (baseWeight < 0)
        baseWeight = 0;
    if (baseWeight > 9)
        baseWeight = 9;

    /* Map from weight value to fcWeights index */
    static int fcWeightLookup[10] = {
        0, 0, 0, 0, 1, 1, 2, 3, 3, 4,
    };

    PRInt32 fcWeight = fcWeightLookup[baseWeight];

    /*
     * adjust by the offset value, make sure we stay inside the
     * fcWeights table
     */
    fcWeight += offset;
    if (fcWeight < 0)
        fcWeight = 0;
    if (fcWeight > 4)
        fcWeight = 4;

    /* Map to final FC_WEIGHT value */
    static int fcWeights[5] = {
        FC_WEIGHT_LIGHT,      /* 0 */
        FC_WEIGHT_MEDIUM,     /* 1 */
        FC_WEIGHT_DEMIBOLD,   /* 2 */
        FC_WEIGHT_BOLD,       /* 3 */
        FC_WEIGHT_BLACK,      /* 4 */
    };

    return fcWeights[fcWeight];
}

void
NS_AddLangGroup(FcPattern *aPattern, nsIAtom *aLangGroup)
{
    // Find the FC lang group for this lang group
    nsCAutoString cname;
    aLangGroup->ToUTF8String(cname);

    // see if the lang group needs to be translated from mozilla's
    // internal mapping into fontconfig's
    const struct MozXftLangGroup *langGroup;
    langGroup = FindFCLangGroup(cname);

    // if there's no lang group, just use the lang group as it was
    // passed to us
    //
    // we're casting away the const here for the strings - should be
    // safe.
    if (!langGroup)
        FcPatternAddString(aPattern, FC_LANG, (FcChar8 *)cname.get());
    else if (langGroup->XftLang)
        FcPatternAddString(aPattern, FC_LANG, (FcChar8 *)langGroup->XftLang);
}

void
NS_AddFFRE(FcPattern *aPattern, nsCString *aFamily, PRBool aWeak)
{
    nsCAutoString family;
    FFREToFamily(*aFamily, family);

    FcValue v;
    v.type = FcTypeString;
    // casting away the const here, should be safe
    v.u.s = (FcChar8 *)family.get();

    if (aWeak)
        FcPatternAddWeak(aPattern, FC_FAMILY, v, FcTrue);
    else
        FcPatternAdd(aPattern, FC_FAMILY, v, FcTrue);
}

/* static */
void
FFREToFamily(nsACString &aFFREName, nsACString &oFamily)
{
  if (NS_FFRECountHyphens(aFFREName) == 3) {
      PRInt32 familyHyphen = aFFREName.FindChar('-') + 1;
      PRInt32 registryHyphen = aFFREName.FindChar('-',familyHyphen);
      oFamily.Append(Substring(aFFREName, familyHyphen,
                               registryHyphen-familyHyphen));
  }
  else {
      oFamily.Append(aFFREName);
  }
}

int
NS_FFRECountHyphens (nsACString &aFFREName)
{
    int h = 0;
    PRInt32 hyphen = 0;
    while ((hyphen = aFFREName.FindChar('-', hyphen)) >= 0) {
        ++h;
        ++hyphen;
    }
    return h;
}

PRBool
NS_IsASCIIFontName(const nsString& aName)
{
    PRUint32 len = aName.Length();
    const PRUnichar* str = aName.get();
    for (PRUint32 i = 0; i < len; i++) {
        /*
         * X font names are printable ASCII, ignore others (for now)
         */
        if ((str[i] < 0x20) || (str[i] > 0x7E)) {
            return PR_FALSE;
        }
    }

    return PR_TRUE;
}




/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is mozilla.org code.
 *
 * The Initial Developer of the Original Code is Christopher Blizzard
 * <blizzard@mozilla.org>.  Portions created by the Initial Developer
 * are Copyright (C) 2002 the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either of the GNU General Public License Version 2 or later (the "GPL"),
 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#ifndef nsFontConfigUtils_h__
#define nsFontConfigUtils_h__

#include "nspr.h"
#include "nsString.h"
#include "nsIAtom.h"
#include "nsFont.h"

#include <fontconfig/fontconfig.h>

extern int     NS_CalculateSlant   (PRUint8  aStyle);
extern int     NS_CalculateWeight  (PRUint16 aWeight);
extern void    NS_AddLangGroup     (FcPattern *aPattern, nsIAtom *aLangGroup);
extern void    NS_AddFFRE          (FcPattern *aPattern, nsCString *aFamily,
                                    PRBool aWeak);
extern int     NS_FFRECountHyphens (nsACString &aFFREName);
extern PRBool  NS_IsASCIIFontName  (const nsString& aName);
#endif


Return to bug 6151

Lines 3419-3432 dnl ==================================== Link Here

(-)configure.in (+4 lines)
3419	dnl = Xft	3419	dnl = Xft
3420	dnl ========================================================	3420	dnl ========================================================
3421	MOZ_ARG_ENABLE_BOOL(xft,	3421	MOZ_ARG_ENABLE_BOOL(xft,
3422	[ --enable-xft Enable Xft support ],	3422	[ --enable-xft Enable Xft support ],
3423	MOZ_ENABLE_XFT=1,	3423	MOZ_ENABLE_XFT=1,
3424	MOZ_ENABLE_XFT= )	3424	MOZ_ENABLE_XFT= )
3425		3425
		3426	if test "$MOZ_ENABLE_XFT" && test "$MOZ_ENABLE_FREETYPE2"; then
		3427	AC_MSG_ERROR([Cannot enable XFT and FREETYPE2 at the same time.])
		3428	fi
		3429
3426	if test "$MOZ_ENABLE_XFT"	3430	if test "$MOZ_ENABLE_XFT"
3427	then	3431	then
3428	AC_DEFINE(MOZ_ENABLE_XFT)	3432	AC_DEFINE(MOZ_ENABLE_XFT)
3429	PKG_CHECK_MODULES(MOZ_XFT, xft)	3433	PKG_CHECK_MODULES(MOZ_XFT, xft)
3430	if test "$MOZ_ENABLE_GTK2"; then	3434	if test "$MOZ_ENABLE_GTK2"; then
3431	PKG_CHECK_MODULES(_PANGOCHK, pango >= 1.1.0)	3435	PKG_CHECK_MODULES(_PANGOCHK, pango >= 1.1.0)
3432	fi	3436	fi

Lines 35-56 XPIDLSRCS = \ Link Here

(-)gfx/idl/Makefile.in (-2 / +7 lines)
35	nsIFontList.idl \	35	nsIFontList.idl \
36	nsIScriptableRegion.idl \	36	nsIScriptableRegion.idl \
37	nsIScreen.idl \	37	nsIScreen.idl \
38	nsIScreenManager.idl \	38	nsIScreenManager.idl \
39	nsIPrintOptions.idl \	39	nsIPrintOptions.idl \
40	nsIPrintSettings.idl \	40	nsIPrintSettings.idl \
41	nsIPrintSettingsService.idl \	41	nsIPrintSettingsService.idl \
42	nsIFontCatalogService.idl \
43	nsIFreeType2.idl \
44	nsIPrintSession.idl \	42	nsIPrintSession.idl \
45	gfxIFormats.idl \	43	gfxIFormats.idl \
46	gfxIImageFrame.idl \	44	gfxIImageFrame.idl \
47	gfxtypes.idl \	45	gfxtypes.idl \
48	$(NULL)	46	$(NULL)
49		47
		48	ifdef MOZ_ENABLE_FREETYPE2
		49	XPIDLSRCS += \
		50	nsIFontCatalogService.idl \
		51	nsIFreeType2.idl \
		52	$(NULL)
		53	endif
		54
50	ifneq (,$(filter mac cocoa,$(MOZ_GFX_TOOLKIT)))	55	ifneq (,$(filter mac cocoa,$(MOZ_GFX_TOOLKIT)))
51	XPIDLSRCS += nsIPrintSettingsX.idl \	56	XPIDLSRCS += nsIPrintSettingsX.idl \
52	nsIPrintSessionX.idl \	57	nsIPrintSessionX.idl \
53	$(NULL)	58	$(NULL)
54	endif	59	endif
55		60
56	ifeq ($(MOZ_GFX_TOOLKIT),windows)	61	ifeq ($(MOZ_GFX_TOOLKIT),windows)

Lines 62-82 endif Link Here

(-)gfx/src/gtk/Makefile.in (-4 / +9 lines)
62	NATIVE_THEME_SUPPORT = 1	62	NATIVE_THEME_SUPPORT = 1
63		63
64	CSRCS = nsPrintdGTK.c	64	CSRCS = nsPrintdGTK.c
65		65
66	# Code shared between GTK+, Xlib and Xprint gfx modules	66	# Code shared between GTK+, Xlib and Xprint gfx modules
67	X11SHARED_LCPPSRCS = \	67	X11SHARED_LCPPSRCS = \
68	nsAntiAliasedGlyph.cpp \	68	nsAntiAliasedGlyph.cpp \
69	nsFontFreeType.cpp \
70	nsFT2FontNode.cpp \
71	nsFT2FontCatalog.cpp \
72	nsX11AlphaBlend.cpp \	69	nsX11AlphaBlend.cpp \
73	nsXFontAAScaledBitmap.cpp \	70	nsXFontAAScaledBitmap.cpp \
74	nsXFontNormal.cpp \	71	nsXFontNormal.cpp \
75	$(NULL)	72	$(NULL)
		73
		74	ifdef MOZ_ENABLE_FREETYPE2
		75	X11SHARED_LCPPSRCS += \
		76	nsFontFreeType.cpp \
		77	nsFT2FontNode.cpp \
		78	nsFT2FontCatalog.cpp \
		79	$(NULL)
		80	endif
76		81
77	CPPSRCS = \	82	CPPSRCS = \
78	nsDeviceContextGTK.cpp \	83	nsDeviceContextGTK.cpp \
79	nsDeviceContextSpecFactoryG.cpp \	84	nsDeviceContextSpecFactoryG.cpp \
80	nsDeviceContextSpecG.cpp \	85	nsDeviceContextSpecG.cpp \
81	nsDrawingSurfaceGTK.cpp \	86	nsDrawingSurfaceGTK.cpp \
82	nsGfxFactoryGTK.cpp \	87	nsGfxFactoryGTK.cpp \
Lines 204-224 EXTRA_DSO_LDOPTS += \ Link Here
204	endif	209	endif
205		210
206	LOCAL_INCLUDES = \	211	LOCAL_INCLUDES = \
207	-I../.. \	212	-I../.. \
208	-I$(srcdir)/. \	213	-I$(srcdir)/. \
209	-I$(srcdir)/.. \	214	-I$(srcdir)/.. \
210	-I$(srcdir)/../shared \	215	-I$(srcdir)/../shared \
211	-I$(srcdir)/../freetype \
212	-I$(srcdir)/../x11shared \	216	-I$(srcdir)/../x11shared \
213	$(MOZ_XFT_CFLAGS) \	217	$(MOZ_XFT_CFLAGS) \
214	$(NULL)	218	$(NULL)
215		219
216	ifdef MOZ_ENABLE_FREETYPE2	220	ifdef MOZ_ENABLE_FREETYPE2
217	INCLUDES += $(FT2_CFLAGS)	221	INCLUDES += $(FT2_CFLAGS)
		222	LOCAL_INCLUDES += -I$(srcdir)/../freetype
218	endif	223	endif
219		224
220	ifdef MOZ_ENABLE_XPRINT	225	ifdef MOZ_ENABLE_XPRINT
221	export:: $(addprefix $(srcdir)/../xprint/,$(XPU_LCSRCS)) $(addprefix $(srcdir)/../x11shared/,$(X11SHARED_LCPPSRCS))	226	export:: $(addprefix $(srcdir)/../xprint/,$(XPU_LCSRCS)) $(addprefix $(srcdir)/../x11shared/,$(X11SHARED_LCPPSRCS))
222	$(INSTALL) $^ .	227	$(INSTALL) $^ .
223	else	228	else
224	export:: $(addprefix $(srcdir)/../x11shared/,$(X11SHARED_LCPPSRCS))	229	export:: $(addprefix $(srcdir)/../x11shared/,$(X11SHARED_LCPPSRCS))

Lines 58-73 Link Here

(-)gfx/src/gtk/nsFontMetricsGTK.cpp (-3 / +176 lines)
58	#include "nsPrintfCString.h"	58	#include "nsPrintfCString.h"
59	#include "nspr.h"	59	#include "nspr.h"
60	#include "nsHashtable.h"	60	#include "nsHashtable.h"
61	#include "nsReadableUtils.h"	61	#include "nsReadableUtils.h"
62	#include "nsAString.h"	62	#include "nsAString.h"
63	#include "nsXPIDLString.h"	63	#include "nsXPIDLString.h"
64	#include "nsFontDebug.h"	64	#include "nsFontDebug.h"
		65	#ifdef MOZ_ENABLE_FREETYPE2
65	#include "nsFT2FontNode.h"	66	#include "nsFT2FontNode.h"
66	#include "nsFontFreeType.h"	67	#include "nsFontFreeType.h"
		68	#endif
67	#include "nsXFontNormal.h"	69	#include "nsXFontNormal.h"
68	#include "nsX11AlphaBlend.h"	70	#include "nsX11AlphaBlend.h"
69	#include "nsXFontAAScaledBitmap.h"	71	#include "nsXFontAAScaledBitmap.h"
70	#include "nsUnicharUtils.h"	72	#include "nsUnicharUtils.h"
71	#ifdef ENABLE_X_FONT_BANNING	73	#ifdef ENABLE_X_FONT_BANNING
72	#include <regex.h>	74	#include <regex.h>
73	#endif /* ENABLE_X_FONT_BANNING */	75	#endif /* ENABLE_X_FONT_BANNING */
Lines 98-125 static PRLogModuleInfo * FontMetricsGTKL Link Here
98	// this factor larger than the height of the display, it's clamped to	100	// this factor larger than the height of the display, it's clamped to
99	// that value instead of the requested size.	101	// that value instead of the requested size.
100	#define FONT_MAX_FONT_SCALE 2	102	#define FONT_MAX_FONT_SCALE 2
101		103
102	#undef NOISY_FONTS	104	#undef NOISY_FONTS
103	#undef REALLY_NOISY_FONTS	105	#undef REALLY_NOISY_FONTS
104		106
		107	#ifndef MOZ_ENABLE_FREETYPE2
		108	static PRUint32 gFontDebug = 0 \| NS_FONT_DEBUG_FONT_SCAN;
		109	#endif
		110
105	struct nsFontCharSetMap;	111	struct nsFontCharSetMap;
106	struct nsFontFamilyName;	112	struct nsFontFamilyName;
107	struct nsFontPropertyName;	113	struct nsFontPropertyName;
108	struct nsFontStyle;	114	struct nsFontStyle;
109	struct nsFontWeight;	115	struct nsFontWeight;
110	struct nsFontLangGroup;	116	struct nsFontLangGroup;
111		117
112	struct nsFontCharSetInfo	118	struct nsFontCharSetInfo
113	{	119	{
114	const char* mCharSet;	120	const char* mCharSet;
115	nsFontCharSetConverter Convert;	121	nsFontCharSetConverter Convert;
116	PRUint8 mSpecialUnderline;	122	PRUint8 mSpecialUnderline;
		123	#ifdef MOZ_ENABLE_FREETYPE2
117	PRInt32 mCodeRange1Bits;	124	PRInt32 mCodeRange1Bits;
118	PRInt32 mCodeRange2Bits;	125	PRInt32 mCodeRange2Bits;
		126	#endif
119	PRUint16* mCCMap;	127	PRUint16* mCCMap;
120	nsIUnicodeEncoder* mConverter;	128	nsIUnicodeEncoder* mConverter;
121	nsIAtom* mLangGroup;	129	nsIAtom* mLangGroup;
122	PRBool mInitedSizeInfo;	130	PRBool mInitedSizeInfo;
123	PRInt32 mOutlineScaleMin;	131	PRInt32 mOutlineScaleMin;
124	PRInt32 mAABitmapScaleMin;	132	PRInt32 mAABitmapScaleMin;
125	double mAABitmapOversize;	133	double mAABitmapOversize;
Lines 216-229 static gint DoubleByteConvert(nsFontChar Link Here
216	const PRUnichar* aSrcBuf, PRInt32 aSrcLen, char* aDestBuf, PRInt32 aDestLen);	224	const PRUnichar* aSrcBuf, PRInt32 aSrcLen, char* aDestBuf, PRInt32 aDestLen);
217	static gint ISO10646Convert(nsFontCharSetInfo* aSelf, XFontStruct* aFont,	225	static gint ISO10646Convert(nsFontCharSetInfo* aSelf, XFontStruct* aFont,
218	const PRUnichar* aSrcBuf, PRInt32 aSrcLen, char* aDestBuf, PRInt32 aDestLen);	226	const PRUnichar* aSrcBuf, PRInt32 aSrcLen, char* aDestBuf, PRInt32 aDestLen);
219		227
220	static nsFontCharSetInfo Unknown = { nsnull };	228	static nsFontCharSetInfo Unknown = { nsnull };
221	static nsFontCharSetInfo Special = { nsnull };	229	static nsFontCharSetInfo Special = { nsnull };
222		230
		231	#ifdef MOZ_ENABLE_FREETYPE2
223	static nsFontCharSetInfo USASCII =	232	static nsFontCharSetInfo USASCII =
224	{ "us-ascii", SingleByteConvert, 0,	233	{ "us-ascii", SingleByteConvert, 0,
225	TT_OS2_CPR1_LATIN1 \| TT_OS2_CPR1_MAC_ROMAN,	234	TT_OS2_CPR1_LATIN1 \| TT_OS2_CPR1_MAC_ROMAN,
226	TT_OS2_CPR2_CA_FRENCH \| TT_OS2_CPR2_PORTUGESE	235	TT_OS2_CPR2_CA_FRENCH \| TT_OS2_CPR2_PORTUGESE
227	\| TT_OS2_CPR2_WE_LATIN1 \| TT_OS2_CPR2_US };	236	\| TT_OS2_CPR2_WE_LATIN1 \| TT_OS2_CPR2_US };
228	static nsFontCharSetInfo ISO88591 =	237	static nsFontCharSetInfo ISO88591 =
229	{ "ISO-8859-1", SingleByteConvert, 0,	238	{ "ISO-8859-1", SingleByteConvert, 0,
Lines 421-435 static nsFontCharSetInfo Mathematica2 = Link Here
421	{ "x-mathematica2", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};	430	{ "x-mathematica2", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};
422	static nsFontCharSetInfo Mathematica3 =	431	static nsFontCharSetInfo Mathematica3 =
423	{ "x-mathematica3", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};	432	{ "x-mathematica3", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};
424	static nsFontCharSetInfo Mathematica4 =	433	static nsFontCharSetInfo Mathematica4 =
425	{ "x-mathematica4", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};	434	{ "x-mathematica4", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};
426	static nsFontCharSetInfo Mathematica5 =	435	static nsFontCharSetInfo Mathematica5 =
427	{ "x-mathematica5", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};	436	{ "x-mathematica5", SingleByteConvert, 0, TT_OS2_CPR1_SYMBOL, 0};
428	#endif	437	#endif /* MATHML */
		438
		439	#else
		440
		441	static nsFontCharSetInfo USASCII =
		442	{ "us-ascii", SingleByteConvert, 0 };
		443	static nsFontCharSetInfo ISO88591 =
		444	{ "ISO-8859-1", SingleByteConvert, 0 };
		445	static nsFontCharSetInfo ISO88592 =
		446	{ "ISO-8859-2", SingleByteConvert, 0 };
		447	static nsFontCharSetInfo ISO88593 =
		448	{ "ISO-8859-3", SingleByteConvert, 0 };
		449	static nsFontCharSetInfo ISO88594 =
		450	{ "ISO-8859-4", SingleByteConvert, 0 };
		451	static nsFontCharSetInfo ISO88595 =
		452	{ "ISO-8859-5", SingleByteConvert, 0 };
		453	static nsFontCharSetInfo ISO88596 =
		454	{ "ISO-8859-6", SingleByteConvert, 0 };
		455	static nsFontCharSetInfo ISO885968x =
		456	{ "x-iso-8859-6-8-x", SingleByteConvert, 0 };
		457	static nsFontCharSetInfo ISO8859616 =
		458	{ "x-iso-8859-6-16", SingleByteConvert, 0 };
		459	static nsFontCharSetInfo IBM1046 =
		460	{ "x-IBM1046", SingleByteConvert, 0 };
		461	static nsFontCharSetInfo ISO88597 =
		462	{ "ISO-8859-7", SingleByteConvert, 0 };
		463	static nsFontCharSetInfo ISO88598 =
		464	{ "ISO-8859-8", SingleByteConvert, 0 };
		465	// change from
		466	// { "ISO-8859-8", SingleByteConvertReverse, 0, 0, 0 };
		467	// untill we fix the layout and ensure we only call this with pure RTL text
		468	static nsFontCharSetInfo ISO88599 =
		469	{ "ISO-8859-9", SingleByteConvert, 0 };
		470	// no support for iso-8859-10 (Nordic/Icelandic) currently
		471	// static nsFontCharSetInfo ISO885910 =
		472	// { "ISO-8859-10", SingleByteConvert, 0,
		473	// 0, TT_OS2_CPR2_NORDIC \| TT_OS2_CPR2_ICELANDIC };
		474	// no support for iso-8859-12 (Vietnamese) currently
		475	// static nsFontCharSetInfo ISO885912 =
		476	// { "ISO-8859-12", SingleByteConvert, 0,
		477	// TT_OS2_CPR1_VIETNAMESE, 0 };
		478	static nsFontCharSetInfo ISO885913 =
		479	{ "ISO-8859-13", SingleByteConvert, 0 };
		480	static nsFontCharSetInfo ISO885915 =
		481	{ "ISO-8859-15", SingleByteConvert, 0 };
		482	static nsFontCharSetInfo JISX0201 =
		483	{ "jis_0201", SingleByteConvert, 1 };
		484	static nsFontCharSetInfo KOI8R =
		485	{ "KOI8-R", SingleByteConvert, 0 };
		486	static nsFontCharSetInfo KOI8U =
		487	{ "KOI8-U", SingleByteConvert, 0 };
		488	static nsFontCharSetInfo TIS6202 =
		489	/* Added to support thai context sensitive shaping if
		490	* CTL extension is is in force */
		491	#ifdef SUNCTL
		492	{ "tis620-2", SingleByteConvert, 0 };
		493	#else
		494	{ "windows-874", SingleByteConvert, 0 };
		495	#endif /* SUNCTL */
		496	static nsFontCharSetInfo TIS620 =
		497	{ "TIS-620", SingleByteConvert, 0 };
		498	static nsFontCharSetInfo ISO885911 =
		499	{ "ISO-8859-11", SingleByteConvert, 0 };
		500	static nsFontCharSetInfo Big5 =
		501	{ "x-x-big5", DoubleByteConvert, 1 };
502	// a kludge to distinguish zh-TW only fonts in Big5 (such as hpbig5-)
503	// from zh-TW/zh-HK common fonts in Big5 (such as big5-1)
504	static nsFontCharSetInfo Big5TWHK =
505	{ "x-x-big5", DoubleByteConvert, 1 };
506	static nsFontCharSetInfo CNS116431 =
507	{ "x-cns-11643-1", DoubleByteConvert, 1 };
508	static nsFontCharSetInfo CNS116432 =
509	{ "x-cns-11643-2", DoubleByteConvert, 1 };
510	static nsFontCharSetInfo CNS116433 =
511	{ "x-cns-11643-3", DoubleByteConvert, 1 };
512	static nsFontCharSetInfo CNS116434 =
513	{ "x-cns-11643-4", DoubleByteConvert, 1 };
514	static nsFontCharSetInfo CNS116435 =
515	{ "x-cns-11643-5", DoubleByteConvert, 1 };
516	static nsFontCharSetInfo CNS116436 =
517	{ "x-cns-11643-6", DoubleByteConvert, 1 };
518	static nsFontCharSetInfo CNS116437 =
519	{ "x-cns-11643-7", DoubleByteConvert, 1 };
520	static nsFontCharSetInfo GB2312 =
521	{ "gb_2312-80", DoubleByteConvert, 1 };
522	static nsFontCharSetInfo GB18030_0 =
523	{ "gb18030.2000-0", DoubleByteConvert, 1 };
524	static nsFontCharSetInfo GB18030_1 =
525	{ "gb18030.2000-1", DoubleByteConvert, 1 };
526	static nsFontCharSetInfo GBK =
527	{ "x-gbk-noascii", DoubleByteConvert, 1 };
528	static nsFontCharSetInfo HKSCS =
529	{ "hkscs-1", DoubleByteConvert, 1 };
530	static nsFontCharSetInfo JISX0208 =
531	{ "jis_0208-1983", DoubleByteConvert, 1 };
532	static nsFontCharSetInfo JISX0212 =
533	{ "jis_0212-1990", DoubleByteConvert, 1 };
534	static nsFontCharSetInfo KSC5601 =
535	{ "ks_c_5601-1987", DoubleByteConvert, 1 };
536	static nsFontCharSetInfo X11Johab =
537	{ "x-x11johab", DoubleByteConvert, 1 };
538	static nsFontCharSetInfo JohabNoAscii =
539	{ "x-johab-noascii", DoubleByteConvert, 1 };
540	static nsFontCharSetInfo JamoTTF =
541	{ "x-koreanjamo-0", DoubleByteConvert, 1 };
542	static nsFontCharSetInfo TamilTTF =
543	{ "x-tamilttf-0", DoubleByteConvert, 0 };
544	static nsFontCharSetInfo CP1250 =
545	{ "windows-1250", SingleByteConvert, 0 };
546	static nsFontCharSetInfo CP1251 =
547	{ "windows-1251", SingleByteConvert, 0 };
548	static nsFontCharSetInfo CP1252 =
549	{ "windows-1252", SingleByteConvert, 0 };
550	static nsFontCharSetInfo CP1253 =
551	{ "windows-1253", SingleByteConvert, 0 };
552	static nsFontCharSetInfo CP1257 =
553	{ "windows-1257", SingleByteConvert, 0 };
554
555	#ifdef SUNCTL
556	/* Hindi range currently unsupported in FT2 range. Change TT* once we
557	arrive at a way to identify hindi */
558	static nsFontCharSetInfo SunIndic =
559	{ "x-sun-unicode-india-0", DoubleByteConvert, 0 };
560	#endif /* SUNCTL */
561
562	static nsFontCharSetInfo ISO106461 =
563	{ nsnull, ISO10646Convert, 1};
564
565	static nsFontCharSetInfo AdobeSymbol =
566	{ "Adobe-Symbol-Encoding", SingleByteConvert, 0 };
567	static nsFontCharSetInfo AdobeEuro =
568	{ "x-adobe-euro", SingleByteConvert, 0 };
569
570	#ifdef MOZ_MATHML
571	static nsFontCharSetInfo CMCMEX =
572	{ "x-t1-cmex", SingleByteConvert, 0};
573	static nsFontCharSetInfo CMCMSY =
574	{ "x-t1-cmsy", SingleByteConvert, 0};
575	static nsFontCharSetInfo CMCMR =
576	{ "x-t1-cmr", SingleByteConvert, 0};
577	static nsFontCharSetInfo CMCMMI =
578	{ "x-t1-cmmi", SingleByteConvert, 0};
579	static nsFontCharSetInfo Mathematica1 =
580	{ "x-mathematica1", SingleByteConvert, 0};
581	static nsFontCharSetInfo Mathematica2 =
582	{ "x-mathematica2", SingleByteConvert, 0};
583	static nsFontCharSetInfo Mathematica3 =
584	{ "x-mathematica3", SingleByteConvert, 0};
585	static nsFontCharSetInfo Mathematica4 =
586	{ "x-mathematica4", SingleByteConvert, 0};
587	static nsFontCharSetInfo Mathematica5 =
588	{ "x-mathematica5", SingleByteConvert, 0};
589	#endif /* MATHML */
590	#endif /* FREETYPE2 */
429		591
430	static nsFontLangGroup FLG_WESTERN = { "x-western", nsnull };	592	static nsFontLangGroup FLG_WESTERN = { "x-western", nsnull };
431	static nsFontLangGroup FLG_RUSSIAN = { "x-cyrillic", nsnull };	593	static nsFontLangGroup FLG_RUSSIAN = { "x-cyrillic", nsnull };
432	static nsFontLangGroup FLG_BALTIC = { "x-baltic", nsnull };	594	static nsFontLangGroup FLG_BALTIC = { "x-baltic", nsnull };
433	static nsFontLangGroup FLG_CE = { "x-central-euro",nsnull };	595	static nsFontLangGroup FLG_CE = { "x-central-euro",nsnull };
434	static nsFontLangGroup FLG_GREEK = { "el", nsnull };	596	static nsFontLangGroup FLG_GREEK = { "el", nsnull };
435	static nsFontLangGroup FLG_TURKISH = { "tr", nsnull };	597	static nsFontLangGroup FLG_TURKISH = { "tr", nsnull };
Lines 817-831 FreeNodeArray(nsHashKey* aKey, void* aDa Link Here
817	static void	979	static void
818	FreeGlobals(void)	980	FreeGlobals(void)
819	{	981	{
820	// XXX complete this	982	// XXX complete this
821		983
822	gInitialized = 0;	984	gInitialized = 0;
823		985
		986	#ifdef MOZ_ENABLE_FREETYPE2
824	nsFT2FontNode::FreeGlobals();	987	nsFT2FontNode::FreeGlobals();
		988	#endif
825		989
826	#ifdef ENABLE_X_FONT_BANNING	990	#ifdef ENABLE_X_FONT_BANNING
827	if (gFontRejectRegEx) {	991	if (gFontRejectRegEx) {
828	regfree(gFontRejectRegEx);	992	regfree(gFontRejectRegEx);
829	delete gFontRejectRegEx;	993	delete gFontRejectRegEx;
830	gFontRejectRegEx = nsnull;	994	gFontRejectRegEx = nsnull;
831	}	995	}
Lines 1217-1235 InitGlobals(nsIDeviceContext *aDevice) Link Here
1217		1381
1218	FreeGlobals();	1382	FreeGlobals();
1219	return NS_ERROR_INVALID_ARG;	1383	return NS_ERROR_INVALID_ARG;
1220	}	1384	}
1221	}	1385	}
1222	#endif /* ENABLE_X_FONT_BANNING */	1386	#endif /* ENABLE_X_FONT_BANNING */
1223		1387
		1388	#ifdef MOZ_ENABLE_FREETYPE2
1224	rv = nsFT2FontNode::InitGlobals();	1389	rv = nsFT2FontNode::InitGlobals();
1225	if (NS_FAILED(rv)) {	1390	if (NS_FAILED(rv)) {
1226	FreeGlobals();	1391	FreeGlobals();
1227	return NS_ERROR_OUT_OF_MEMORY;	1392	return NS_ERROR_OUT_OF_MEMORY;
1228	}	1393	}
		1394	#endif
1229		1395
1230	gInitialized = 1;	1396	gInitialized = 1;
1231		1397
1232	return NS_OK;	1398	return NS_OK;
1233	}	1399	}
1234		1400
1235	// do the 8 to 16 bit conversion on the stack	1401	// do the 8 to 16 bit conversion on the stack
Lines 1553-1575 NS_IMETHODIMP nsFontMetricsGTK::Destroy Link Here
1553	}	1719	}
1554		1720
1555	void nsFontMetricsGTK::RealizeFont()	1721	void nsFontMetricsGTK::RealizeFont()
1556	{	1722	{
1557	float f;	1723	float f;
1558	f = mDeviceContext->DevUnitsToAppUnits();	1724	f = mDeviceContext->DevUnitsToAppUnits();
1559		1725
		1726	#ifdef MOZ_ENABLE_FREETYPE2
1560	if (mWesternFont->IsFreeTypeFont()) {	1727	if (mWesternFont->IsFreeTypeFont()) {
1561	nsFreeTypeFont ft = (nsFreeTypeFont )mWesternFont;	1728	nsFreeTypeFont ft = (nsFreeTypeFont )mWesternFont;
1562	if (!ft)	1729	if (!ft)
1563	return;	1730	return;
1564	// now that there are multiple font types (eg: core X fonts	1731	// now that there are multiple font types (eg: core X fonts
1565	// and TrueType fonts) there should be a common set of methods	1732	// and TrueType fonts) there should be a common set of methods
1566	// to get the metrics info from the font object. These methods	1733	// to get the metrics info from the font object. These methods
1567	// probably should be virtual functions defined in nsFontGTK.	1734	// probably should be virtual functions defined in nsFontGTK.
1568	#if (defined(MOZ_ENABLE_FREETYPE2))
1569	int lineSpacing = ft->ascent() + ft->descent();	1735	int lineSpacing = ft->ascent() + ft->descent();
1570	if (lineSpacing > mWesternFont->mSize) {	1736	if (lineSpacing > mWesternFont->mSize) {
1571	mLeading = nscoord((lineSpacing - mWesternFont->mSize) * f);	1737	mLeading = nscoord((lineSpacing - mWesternFont->mSize) * f);
1572	}	1738	}
1573	else {	1739	else {
1574	mLeading = 0;	1740	mLeading = 0;
1575	}	1741	}
Lines 1633-1648 void nsFontMetricsGTK::RealizeFont() Link Here
1633	}	1799	}
1634		1800
1635	/* need better way to calculate this */	1801	/* need better way to calculate this */
1636	mStrikeoutOffset = NSToCoordRound(mXHeight / 2.0);	1802	mStrikeoutOffset = NSToCoordRound(mXHeight / 2.0);
1637	mStrikeoutSize = mUnderlineSize;	1803	mStrikeoutSize = mUnderlineSize;
1638		1804
1639	return;	1805	return;
1640	#endif /* (defined(MOZ_ENABLE_FREETYPE2)) */
1641	}	1806	}
		1807	#endif
1642	nsXFont *xFont = mWesternFont->GetXFont();	1808	nsXFont *xFont = mWesternFont->GetXFont();
1643	XFontStruct *fontInfo = xFont->GetXFontStruct();	1809	XFontStruct *fontInfo = xFont->GetXFontStruct();
1644	f = mDeviceContext->DevUnitsToAppUnits();	1810	f = mDeviceContext->DevUnitsToAppUnits();
1645		1811
1646	nscoord lineSpacing = nscoord((fontInfo->ascent + fontInfo->descent) * f);	1812	nscoord lineSpacing = nscoord((fontInfo->ascent + fontInfo->descent) * f);
1647	mEmHeight = PR_MAX(1, nscoord(mWesternFont->mSize * f));	1813	mEmHeight = PR_MAX(1, nscoord(mWesternFont->mSize * f));
1648	if (lineSpacing > mEmHeight) {	1814	if (lineSpacing > mEmHeight) {
Lines 3251-3264 nsFontMetricsGTK::GetAASBBaseFont(nsFont Link Here
3251	return base_aafont;	3417	return base_aafont;
3252	}	3418	}
3253		3419
3254	nsFontGTK*	3420	nsFontGTK*
3255	nsFontMetricsGTK::PickASizeAndLoad(nsFontStretch* aStretch,	3421	nsFontMetricsGTK::PickASizeAndLoad(nsFontStretch* aStretch,
3256	nsFontCharSetInfo* aCharSet, PRUint32 aChar, const char *aName)	3422	nsFontCharSetInfo* aCharSet, PRUint32 aChar, const char *aName)
3257	{	3423	{
		3424
		3425	#ifdef MOZ_ENABLE_FREETYPE2
3258	if (aStretch->mFreeTypeFaceID) {	3426	if (aStretch->mFreeTypeFaceID) {
3259	//FREETYPE_FONT_PRINTF(("mFreeTypeFaceID = 0x%p", aStretch->mFreeTypeFaceID));	3427	//FREETYPE_FONT_PRINTF(("mFreeTypeFaceID = 0x%p", aStretch->mFreeTypeFaceID));
3260	nsFreeTypeFont *ftfont = nsFreeTypeFont::NewFont(aStretch->mFreeTypeFaceID,	3428	nsFreeTypeFont *ftfont = nsFreeTypeFont::NewFont(aStretch->mFreeTypeFaceID,
3261	mPixelSize,	3429	mPixelSize,
3262	aName);	3430	aName);
3263	if (!ftfont) {	3431	if (!ftfont) {
3264	FREETYPE_FONT_PRINTF(("failed to create font"));	3432	FREETYPE_FONT_PRINTF(("failed to create font"));
Lines 3283-3296 nsFontMetricsGTK::PickASizeAndLoad(nsFon Link Here
3283	return AddToLoadedFontsList(ftfont);	3451	return AddToLoadedFontsList(ftfont);
3284	}	3452	}
3285		3453
3286	if (IS_SURROGATE(aChar)) {	3454	if (IS_SURROGATE(aChar)) {
3287	// SURROGATE is only supported by FreeType	3455	// SURROGATE is only supported by FreeType
3288	return nsnull;	3456	return nsnull;
3289	}	3457	}
		3458	#endif
3290		3459
3291	PRBool use_scaled_font = PR_FALSE;	3460	PRBool use_scaled_font = PR_FALSE;
3292	PRBool have_nearly_rightsized_bitmap = PR_FALSE;	3461	PRBool have_nearly_rightsized_bitmap = PR_FALSE;
3293	nsFontGTK* base_aafont = nsnull;	3462	nsFontGTK* base_aafont = nsnull;
3294		3463
3295	PRInt32 bitmap_size = NOT_FOUND_FONT_SIZE;	3464	PRInt32 bitmap_size = NOT_FOUND_FONT_SIZE;
3296	PRInt32 scale_size = mPixelSize;	3465	PRInt32 scale_size = mPixelSize;
Lines 5191-5206 GetFontNames(const char* aPattern, PRBoo Link Here
5191	{	5360	{
5192	#ifdef NS_FONT_DEBUG_CALL_TRACE	5361	#ifdef NS_FONT_DEBUG_CALL_TRACE
5193	if (gFontDebug & NS_FONT_DEBUG_CALL_TRACE) {	5362	if (gFontDebug & NS_FONT_DEBUG_CALL_TRACE) {
5194	printf("GetFontNames %s\n", aPattern);	5363	printf("GetFontNames %s\n", aPattern);
5195	}	5364	}
5196	#endif	5365	#endif
5197		5366
		5367	#ifdef MOZ_ENABLE_FREETYPE2
5198	// get FreeType fonts	5368	// get FreeType fonts
5199	nsFT2FontNode::GetFontNames(aPattern, aNodes);	5369	nsFT2FontNode::GetFontNames(aPattern, aNodes);
		5370	#endif
5200		5371
5201	nsCAutoString previousNodeName;	5372	nsCAutoString previousNodeName;
5202	nsHashtable* node_hash;	5373	nsHashtable* node_hash;
5203	if (aAnyFoundry) {	5374	if (aAnyFoundry) {
5204	NS_ASSERTION(aPattern[1] == '*', "invalid 'anyFoundry' pattern");	5375	NS_ASSERTION(aPattern[1] == '*', "invalid 'anyFoundry' pattern");
5205	node_hash = gAFRENodes;	5376	node_hash = gAFRENodes;
5206	}	5377	}
Lines 6565-6582 GetCharSetMap(const char *aCharSetName) Link Here
6565	nsFontCharSetMap* charSetMap =	6736	nsFontCharSetMap* charSetMap =
6566	(nsFontCharSetMap*) gCharSetMaps->Get(&charSetKey);	6737	(nsFontCharSetMap*) gCharSetMaps->Get(&charSetKey);
6567	if (!charSetMap)	6738	if (!charSetMap)
6568	charSetMap = gNoneCharSetMap;	6739	charSetMap = gNoneCharSetMap;
6569	return charSetMap;	6740	return charSetMap;
6570	}	6741	}
6571		6742
		6743	#ifdef MOZ_ENABLE_FREETYPE2
6572	void	6744	void
6573	CharSetNameToCodeRangeBits(const char *aCharset,	6745	CharSetNameToCodeRangeBits(const char *aCharset,
6574	PRUint32 aCodeRange1, PRUint32 aCodeRange2)	6746	PRUint32 aCodeRange1, PRUint32 aCodeRange2)
6575	{	6747	{
6576	nsFontCharSetMap *charSetMap = GetCharSetMap(aCharset);	6748	nsFontCharSetMap *charSetMap = GetCharSetMap(aCharset);
6577	nsFontCharSetInfo* charSetInfo = charSetMap->mInfo;	6749	nsFontCharSetInfo* charSetInfo = charSetMap->mInfo;
6578		6750
6579	*aCodeRange1 = charSetInfo->mCodeRange1Bits;	6751	*aCodeRange1 = charSetInfo->mCodeRange1Bits;
6580	*aCodeRange2 = charSetInfo->mCodeRange2Bits;	6752	*aCodeRange2 = charSetInfo->mCodeRange2Bits;
6581	}	6753	}
		6754	#endif
6582		6755

Lines 48-62 Link Here

(-)gfx/src/gtk/nsFontMetricsGTK.h (+6 lines)
48	#include "nsIDeviceContext.h"	48	#include "nsIDeviceContext.h"
49	#include "nsCRT.h"	49	#include "nsCRT.h"
50	#include "nsCOMPtr.h"	50	#include "nsCOMPtr.h"
51	#include "nsRenderingContextGTK.h"	51	#include "nsRenderingContextGTK.h"
52	#include "nsICharRepresentable.h"	52	#include "nsICharRepresentable.h"
53	#include "nsCompressedCharMap.h"	53	#include "nsCompressedCharMap.h"
54	#include "nsIFontMetricsGTK.h"	54	#include "nsIFontMetricsGTK.h"
		55	#ifdef MOZ_ENABLE_FREETYPE2
55	#include "nsIFontCatalogService.h"	56	#include "nsIFontCatalogService.h"
		57	#endif
56		58
57	#include <gdk/gdk.h>	59	#include <gdk/gdk.h>
58	#include <gdk/gdkx.h>	60	#include <gdk/gdkx.h>
59		61
60	#undef FONT_HAS_GLYPH	62	#undef FONT_HAS_GLYPH
61	#define FONT_HAS_GLYPH(map, char) IS_REPRESENTABLE(map, char)	63	#define FONT_HAS_GLYPH(map, char) IS_REPRESENTABLE(map, char)
62	#define WEIGHT_INDEX(weight) (((weight) / 100) - 1)	64	#define WEIGHT_INDEX(weight) (((weight) / 100) - 1)
Lines 88-102 struct nsFontStretch Link Here
88	nsFontGTK** mSizes;	90	nsFontGTK** mSizes;
89	PRUint16 mSizesAlloc;	91	PRUint16 mSizesAlloc;
90	PRUint16 mSizesCount;	92	PRUint16 mSizesCount;
91		93
92	char* mScalable;	94	char* mScalable;
93	PRBool mOutlineScaled;	95	PRBool mOutlineScaled;
94	nsVoidArray mScaledFonts;	96	nsVoidArray mScaledFonts;
		97	#ifdef MOZ_ENABLE_FREETYPE2
95	nsITrueTypeFontCatalogEntry* mFreeTypeFaceID;	98	nsITrueTypeFontCatalogEntry* mFreeTypeFaceID;
		99	#endif
96	};	100	};
97		101
98	struct nsFontStyle	102	struct nsFontStyle
99	{	103	{
100	NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW	104	NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
101		105
102	void FillWeightHoles(void);	106	void FillWeightHoles(void);
Lines 407-420 public: Link Here
407	NS_DECL_ISUPPORTS	411	NS_DECL_ISUPPORTS
408	NS_DECL_NSIFONTENUMERATOR	412	NS_DECL_NSIFONTENUMERATOR
409	};	413	};
410		414
411	class nsHashKey;	415	class nsHashKey;
412	PRBool FreeNode(nsHashKey* aKey, void* aData, void* aClosure);	416	PRBool FreeNode(nsHashKey* aKey, void* aData, void* aClosure);
413	nsFontCharSetInfo GetCharSetInfo(const char aCharSetName);	417	nsFontCharSetInfo GetCharSetInfo(const char aCharSetName);
		418	#ifdef MOZ_ENABLE_FREETYPE2
414	void CharSetNameToCodeRangeBits(const char, PRUint32, PRUint32*);	419	void CharSetNameToCodeRangeBits(const char, PRUint32, PRUint32*);
		420	#endif
415	nsFontCharSetMap GetCharSetMap(const char aCharSetName);	421	nsFontCharSetMap GetCharSetMap(const char aCharSetName);
416		422
417		423
418		424
419		425
420	#endif	426	#endif

Lines 60-73 Link Here

(-)gfx/src/gtk/nsFontMetricsXft.cpp (-217 / +14 lines)
60	#include "nsICharsetConverterManager.h"	60	#include "nsICharsetConverterManager.h"
61	#include "nsICharRepresentable.h"	61	#include "nsICharRepresentable.h"
62	#include "nsIPersistentProperties2.h"	62	#include "nsIPersistentProperties2.h"
63	#include "nsCompressedCharMap.h"	63	#include "nsCompressedCharMap.h"
64	#include "nsNetUtil.h"	64	#include "nsNetUtil.h"
65	#include "nsClassHashtable.h"	65	#include "nsClassHashtable.h"
66	#include "nsAutoBuffer.h"	66	#include "nsAutoBuffer.h"
		67	#include "nsFontConfigUtils.h"
67		68
68	#include <gdk/gdkx.h>	69	#include <gdk/gdkx.h>
69	#include <freetype/tttables.h>	70	#include <freetype/tttables.h>
70	#include <freetype/freetype.h>	71	#include <freetype/freetype.h>
71		72
72	#define FORCE_PR_LOG	73	#define FORCE_PR_LOG
73	#include "prlog.h"	74	#include "prlog.h"
Lines 190-223 class nsFontXftInfo { Link Here
190	// Unicode, Custom, CustomWide	191	// Unicode, Custom, CustomWide
191	nsXftFontType mFontType;	192	nsXftFontType mFontType;
192	// Truetype cmap to use for direct retrieval of GIDs with FT_Get_Char_Index	193	// Truetype cmap to use for direct retrieval of GIDs with FT_Get_Char_Index
193	// for 'narrow' custom fonts.	194	// for 'narrow' custom fonts.
194	FT_Encoding mFT_Encoding;	195	FT_Encoding mFT_Encoding;
195	};	196	};
196		197
197	struct MozXftLangGroup {
198	const char *mozLangGroup;
199	FcChar32 character;
200	const FcChar8 *XftLang;
201	};
202
203	static const MozXftLangGroup MozXftLangGroups[] = {
204	{ "x-western", 0x0041, (const FcChar8 *)"en" },
205	{ "x-central-euro", 0x0100, (const FcChar8 *)"pl" },
206	{ "x-cyrillic", 0x0411, (const FcChar8 *)"ru" },
207	{ "x-baltic", 0x0104, (const FcChar8 *)"lv" },
208	{ "x-devanagari", 0x0905, (const FcChar8 *)"hi" },
209	{ "x-tamil", 0x0B85, (const FcChar8 *)"ta" },
210	{ "x-unicode", 0x0000, 0 },
211	{ "x-user-def", 0x0000, 0 },
212	};
213
214	#define NUM_XFT_LANG_GROUPS (sizeof (MozXftLangGroups) / \
215	sizeof (MozXftLangGroups[0]))
216
217	struct DrawStringData {	198	struct DrawStringData {
218	nscoord x;	199	nscoord x;
219	nscoord y;	200	nscoord y;
220	const nscoord *spacing;	201	const nscoord *spacing;
221	nscoord xOffset;	202	nscoord xOffset;
222	nsRenderingContextGTK *context;	203	nsRenderingContextGTK *context;
223	XftDraw *draw;	204	XftDraw *draw;
Lines 232-260 struct BoundingMetricsData { Link Here
232	PRBool firstTime;	213	PRBool firstTime;
233	};	214	};
234	#endif /* MOZ_MATHML */	215	#endif /* MOZ_MATHML */
235		216
236	#define AUTO_BUFFER_SIZE 3000	217	#define AUTO_BUFFER_SIZE 3000
237	typedef nsAutoBuffer<FcChar32, AUTO_BUFFER_SIZE> nsAutoFcChar32Buffer;	218	typedef nsAutoBuffer<FcChar32, AUTO_BUFFER_SIZE> nsAutoFcChar32Buffer;
238		219
239	static int CalculateSlant (PRUint8 aStyle);
240	static int CalculateWeight (PRUint16 aWeight);
241	static void AddLangGroup (FcPattern aPattern, nsIAtom aLangGroup);
242	static void AddFFRE (FcPattern aPattern, nsCString aFamily,
243	PRBool aWeak);
244	static void FFREToFamily (nsACString &aFFREName, nsACString &oFamily);
245	static int FFRECountHyphens (nsACString &aFFREName);
246	static int CompareFontNames (const void* aArg1, const void* aArg2,	220	static int CompareFontNames (const void* aArg1, const void* aArg2,
247	void* aClosure);	221	void* aClosure);
248	static PRBool IsASCIIFontName (const nsString& aName);
249	static nsresult EnumFontsXft (nsIAtom* aLangGroup, const char* aGeneric,	222	static nsresult EnumFontsXft (nsIAtom* aLangGroup, const char* aGeneric,
250	PRUint32* aCount, PRUnichar*** aResult);	223	PRUint32* aCount, PRUnichar*** aResult);
251		224
252	static const MozXftLangGroup* FindFCLangGroup (nsACString &aLangGroup);
253
254	static void ConvertCharToUCS4 (const char *aString,	225	static void ConvertCharToUCS4 (const char *aString,
255	PRUint32 aLength,	226	PRUint32 aLength,
256	nsAutoFcChar32Buffer &aOutBuffer,	227	nsAutoFcChar32Buffer &aOutBuffer,
257	PRUint32 *aOutLen);	228	PRUint32 *aOutLen);
258	static void ConvertUnicharToUCS4 (const PRUnichar *aString,	229	static void ConvertUnicharToUCS4 (const PRUnichar *aString,
259	PRUint32 aLength,	230	PRUint32 aLength,
260	nsAutoFcChar32Buffer &aOutBuffer,	231	nsAutoFcChar32Buffer &aOutBuffer,
Lines 1018-1038 nsFontMetricsXft::SetupFCPattern(void) Link Here
1018	for (int i=0; i < mFontList.Count(); ++i) {	989	for (int i=0; i < mFontList.Count(); ++i) {
1019	// if this was a generic name, break out of the loop since we	990	// if this was a generic name, break out of the loop since we
1020	// don't want to add it to the pattern yet	991	// don't want to add it to the pattern yet
1021	if (mFontIsGeneric[i])	992	if (mFontIsGeneric[i])
1022	break;;	993	break;;
1023		994
1024	nsCString *familyName = mFontList.CStringAt(i);	995	nsCString *familyName = mFontList.CStringAt(i);
1025	AddFFRE(mPattern, familyName, PR_FALSE);	996	NS_AddFFRE(mPattern, familyName, PR_FALSE);
1026	}	997	}
1027		998
1028	// Add the language group. Note that we do this before adding any	999	// Add the language group. Note that we do this before adding any
1029	// generics. That's because the language is more important than	1000	// generics. That's because the language is more important than
1030	// any generic font.	1001	// any generic font.
1031	AddLangGroup (mPattern, mLangGroup);	1002	NS_AddLangGroup (mPattern, mLangGroup);
1032		1003
1033	// If there's a generic add a pref for the generic if there's one	1004	// If there's a generic add a pref for the generic if there's one
1034	// set.	1005	// set.
1035	if (mGenericFont && !mFont->systemFont) {	1006	if (mGenericFont && !mFont->systemFont) {
1036	nsCString name;	1007	nsCString name;
1037	name += "font.name.";	1008	name += "font.name.";
1038	name += mGenericFont->get();	1009	name += mGenericFont->get();
Lines 1048-1078 nsFontMetricsXft::SetupFCPattern(void) Link Here
1048	if (pref) {	1019	if (pref) {
1049	nsresult rv;	1020	nsresult rv;
1050	nsXPIDLCString value;	1021	nsXPIDLCString value;
1051	rv = pref->GetCharPref(name.get(), getter_Copies(value));	1022	rv = pref->GetCharPref(name.get(), getter_Copies(value));
1052		1023
1053	// we ignore prefs that have three hypens since they are X	1024	// we ignore prefs that have three hypens since they are X
1054	// style prefs.	1025	// style prefs.
1055	if (FFRECountHyphens(value) < 3) {	1026	if (NS_FFRECountHyphens(value) < 3) {
1056	nsCString tmpstr;	1027	nsCString tmpstr;
1057	tmpstr.Append(value);	1028	tmpstr.Append(value);
1058		1029
1059	if (PR_LOG_TEST(gXftFontLoad, PR_LOG_DEBUG)) {	1030	if (PR_LOG_TEST(gXftFontLoad, PR_LOG_DEBUG)) {
1060	printf("\tadding generic font from preferences: %s\n",	1031	printf("\tadding generic font from preferences: %s\n",
1061	tmpstr.get());	1032	tmpstr.get());
1062	}	1033	}
1063		1034
1064	AddFFRE(mPattern, &tmpstr, PR_FALSE);	1035	NS_AddFFRE(mPattern, &tmpstr, PR_FALSE);
1065	}	1036	}
1066	}	1037	}
1067	}	1038	}
1068		1039
1069	// Add the generic if there is one.	1040	// Add the generic if there is one.
1070	if (mGenericFont && !mFont->systemFont)	1041	if (mGenericFont && !mFont->systemFont)
1071	AddFFRE(mPattern, mGenericFont, PR_FALSE);	1042	NS_AddFFRE(mPattern, mGenericFont, PR_FALSE);
1072		1043
1073	if (PR_LOG_TEST(gXftFontLoad, PR_LOG_DEBUG)) {	1044	if (PR_LOG_TEST(gXftFontLoad, PR_LOG_DEBUG)) {
1074	// generic font	1045	// generic font
1075	if (mGenericFont && !mFont->systemFont) {	1046	if (mGenericFont && !mFont->systemFont) {
1076	printf("\tadding generic family: %s\n", mGenericFont->get());	1047	printf("\tadding generic family: %s\n", mGenericFont->get());
1077	}	1048	}
1078		1049
Lines 1091-1121 nsFontMetricsXft::SetupFCPattern(void) Link Here
1091	default:	1062	default:
1092	printf("roman\n");	1063	printf("roman\n");
1093	break;	1064	break;
1094	}	1065	}
1095		1066
1096	// weight	1067	// weight
1097	printf("\tweight: (orig,calc) %d,%d\n",	1068	printf("\tweight: (orig,calc) %d,%d\n",
1098	mFont->weight, CalculateWeight(mFont->weight));	1069	mFont->weight, NS_CalculateWeight(mFont->weight));
1099		1070
1100	}	1071	}
1101		1072
1102	// add the point size	1073	// add the point size
1103	// We've done some round-tripping of floating point numbers so they	1074	// We've done some round-tripping of floating point numbers so they
1104	// might not be quite right. Since Xft rounds down, add a little,	1075	// might not be quite right. Since Xft rounds down, add a little,
1105	// so we don't go from 9.00000 to 8.99999 to 8.	1076	// so we don't go from 9.00000 to 8.99999 to 8.
1106	FcPatternAddDouble(mPattern, FC_PIXEL_SIZE, mPixelSize + 0.000001);	1077	FcPatternAddDouble(mPattern, FC_PIXEL_SIZE, mPixelSize + 0.000001);
1107		1078
1108	// Add the slant type	1079	// Add the slant type
1109	FcPatternAddInteger(mPattern, FC_SLANT,	1080	FcPatternAddInteger(mPattern, FC_SLANT,
1110	CalculateSlant(mFont->style));	1081	NS_CalculateSlant(mFont->style));
1111		1082
1112	// Add the weight	1083	// Add the weight
1113	FcPatternAddInteger(mPattern, FC_WEIGHT,	1084	FcPatternAddInteger(mPattern, FC_WEIGHT,
1114	CalculateWeight(mFont->weight));	1085	NS_CalculateWeight(mFont->weight));
1115		1086
1116	// Set up the default substitutions for this font	1087	// Set up the default substitutions for this font
1117	FcConfigSubstitute(0, mPattern, FcMatchPattern);	1088	FcConfigSubstitute(0, mPattern, FcMatchPattern);
1118	XftDefaultSubstitute(GDK_DISPLAY(), DefaultScreen(GDK_DISPLAY()),	1089	XftDefaultSubstitute(GDK_DISPLAY(), DefaultScreen(GDK_DISPLAY()),
1119	mPattern);	1090	mPattern);
1120	}	1091	}
1121		1092
Lines 1270-1284 nsFontMetricsXft::SetupMiniFont(void) Link Here
1270	XftPatternAddBool(mPattern, XFT_RENDER, False);	1241	XftPatternAddBool(mPattern, XFT_RENDER, False);
1271		1242
1272	FcPatternAddString(pattern, FC_FAMILY, (FcChar8 *)"monospace");	1243	FcPatternAddString(pattern, FC_FAMILY, (FcChar8 *)"monospace");
1273		1244
1274	FcPatternAddInteger(pattern, FC_PIXEL_SIZE, int(0.5 * mPixelSize));	1245	FcPatternAddInteger(pattern, FC_PIXEL_SIZE, int(0.5 * mPixelSize));
1275		1246
1276	FcPatternAddInteger(pattern, FC_WEIGHT,	1247	FcPatternAddInteger(pattern, FC_WEIGHT,
1277	CalculateWeight(mFont->weight));	1248	NS_CalculateWeight(mFont->weight));
1278		1249
1279	FcConfigSubstitute(0, pattern, FcMatchPattern);	1250	FcConfigSubstitute(0, pattern, FcMatchPattern);
1280	XftDefaultSubstitute(GDK_DISPLAY(), DefaultScreen(GDK_DISPLAY()),	1251	XftDefaultSubstitute(GDK_DISPLAY(), DefaultScreen(GDK_DISPLAY()),
1281	pattern);	1252	pattern);
1282		1253
1283	FcResult res;	1254	FcResult res;
1284		1255
Lines 1686-1700 nsFontMetricsXft::BoundingMetricsCallbac Link Here
1686	#endif /* MOZ_MATHML */	1657	#endif /* MOZ_MATHML */
1687		1658
1688	/* static */	1659	/* static */
1689	nsresult	1660	nsresult
1690	nsFontMetricsXft::FamilyExists(nsIDeviceContext *aDevice,	1661	nsFontMetricsXft::FamilyExists(nsIDeviceContext *aDevice,
1691	const nsString &aName)	1662	const nsString &aName)
1692	{	1663	{
1693	if (!IsASCIIFontName(aName))	1664	if (!NS_IsASCIIFontName(aName))
1694	return NS_ERROR_FAILURE;	1665	return NS_ERROR_FAILURE;
1695		1666
1696	NS_ConvertUCS2toUTF8 name(aName);	1667	NS_ConvertUCS2toUTF8 name(aName);
1697		1668
1698	FcFontSet *set = nsnull;	1669	FcFontSet *set = nsnull;
1699	FcObjectSet *os = nsnull;	1670	FcObjectSet *os = nsnull;
1700		1671
Lines 1744-1758 nsFontMetricsXft::FamilyExists(nsIDevice Link Here
1744	/* static */	1715	/* static */
1745	PRBool	1716	PRBool
1746	nsFontMetricsXft::EnumFontCallback(const nsString &aFamily, PRBool aIsGeneric,	1717	nsFontMetricsXft::EnumFontCallback(const nsString &aFamily, PRBool aIsGeneric,
1747	void *aData)	1718	void *aData)
1748	{	1719	{
1749	// make sure it's an ascii name, if not then return and continue	1720	// make sure it's an ascii name, if not then return and continue
1750	// enumerating	1721	// enumerating
1751	if (!IsASCIIFontName(aFamily))	1722	if (!NS_IsASCIIFontName(aFamily))
1752	return PR_TRUE;	1723	return PR_TRUE;
1753		1724
1754	nsCAutoString name;	1725	nsCAutoString name;
1755	name.AssignWithConversion(aFamily.get());	1726	name.AssignWithConversion(aFamily.get());
1756	ToLowerCase(name);	1727	ToLowerCase(name);
1757	nsFontMetricsXft metrics = (nsFontMetricsXft )aData;	1728	nsFontMetricsXft metrics = (nsFontMetricsXft )aData;
1758	metrics->mFontList.AppendCString(name);	1729	metrics->mFontList.AppendCString(name);
Lines 1842-1856 nsFontEnumeratorXft::GetDefaultFont(cons Link Here
1842	match_pattern = FcPatternCreate();	1813	match_pattern = FcPatternCreate();
1843		1814
1844	if (!match_pattern)	1815	if (!match_pattern)
1845	return NS_OK; // not fatal, just return an empty default name	1816	return NS_OK; // not fatal, just return an empty default name
1846		1817
1847	if (aLangGroup && *aLangGroup) {	1818	if (aLangGroup && *aLangGroup) {
1848	nsCOMPtr<nsIAtom> langGroup = do_GetAtom(aLangGroup);	1819	nsCOMPtr<nsIAtom> langGroup = do_GetAtom(aLangGroup);
1849	AddLangGroup(match_pattern, langGroup);	1820	NS_AddLangGroup(match_pattern, langGroup);
1850	}	1821	}
1851		1822
1852	FcConfigSubstitute(0, match_pattern, FcMatchPattern);	1823	FcConfigSubstitute(0, match_pattern, FcMatchPattern);
1853	FcDefaultSubstitute(match_pattern);	1824	FcDefaultSubstitute(match_pattern);
1854	FcPattern* result_pattern = FcFontMatch(0, match_pattern, &res);	1825	FcPattern* result_pattern = FcFontMatch(0, match_pattern, &res);
1855	if (result_pattern) {	1826	if (result_pattern) {
1856	char *family;	1827	char *family;
Lines 2227-2408 nsAutoDrawSpecBuffer::Flush() Link Here
2227	}	2198	}
2228	}	2199	}
2229		2200
2230	// Static functions	2201	// Static functions
2231		2202
2232	/* static */	2203	/* static */
2233	int	2204	int
2234	CalculateSlant(PRUint8 aStyle)
2235	{
2236	int fcSlant;
2237
2238	switch(aStyle) {
2239	case NS_FONT_STYLE_ITALIC:
2240	fcSlant = FC_SLANT_ITALIC;
2241	break;
2242	case NS_FONT_STYLE_OBLIQUE:
2243	fcSlant = FC_SLANT_OBLIQUE;
2244	break;
2245	default:
2246	fcSlant = FC_SLANT_ROMAN;
2247	break;
2248	}
2249
2250	return fcSlant;
2251	}
2252
2253	/* static */
2254	int
2255	CalculateWeight (PRUint16 aWeight)
2256	{
2257	/*
2258	* weights come in two parts crammed into one
2259	* integer -- the "base" weight is weight / 100,
2260	* the rest of the value is the "offset" from that
2261	* weight -- the number of steps to move to adjust
2262	* the weight in the list of supported font weights,
2263	* this value can be negative or positive.
2264	*/
2265	PRInt32 baseWeight = (aWeight + 50) / 100;
2266	PRInt32 offset = aWeight - baseWeight * 100;
2267
2268	/* clip weights to range 0 to 9 */
2269	if (baseWeight < 0)
2270	baseWeight = 0;
2271	if (baseWeight > 9)
2272	baseWeight = 9;
2273
2274	/* Map from weight value to fcWeights index */
2275	static int fcWeightLookup[10] = {
2276	0, 0, 0, 0, 1, 1, 2, 3, 3, 4,
2277	};
2278
2279	PRInt32 fcWeight = fcWeightLookup[baseWeight];
2280
2281	/*
2282	* adjust by the offset value, make sure we stay inside the
2283	* fcWeights table
2284	*/
2285	fcWeight += offset;
2286
2287	if (fcWeight < 0)
2288	fcWeight = 0;
2289	if (fcWeight > 4)
2290	fcWeight = 4;
2291
2292	/* Map to final FC_WEIGHT value */
2293	static int fcWeights[5] = {
2294	FC_WEIGHT_LIGHT, /* 0 */
2295	FC_WEIGHT_MEDIUM, /* 1 */
2296	FC_WEIGHT_DEMIBOLD, /* 2 */
2297	FC_WEIGHT_BOLD, /* 3 */
2298	FC_WEIGHT_BLACK, /* 4 */
2299	};
2300
2301	return fcWeights[fcWeight];
2302
2303	}
2304
2305	/* static */
2306	void
2307	AddLangGroup(FcPattern aPattern, nsIAtom aLangGroup)
2308	{
2309	// Find the FC lang group for this lang group
2310	nsCAutoString cname;
2311	aLangGroup->ToUTF8String(cname);
2312
2313	// see if the lang group needs to be translated from mozilla's
2314	// internal mapping into fontconfig's
2315	const struct MozXftLangGroup *langGroup;
2316	langGroup = FindFCLangGroup(cname);
2317
2318	// if there's no lang group, just use the lang group as it was
2319	// passed to us
2320	//
2321	// we're casting away the const here for the strings - should be
2322	// safe.
2323	if (!langGroup)
2324	FcPatternAddString(aPattern, FC_LANG, (FcChar8 *)cname.get());
2325	else if (langGroup->XftLang)
2326	FcPatternAddString(aPattern, FC_LANG, (FcChar8 *)langGroup->XftLang);
2327	}
2328
2329	/* static */
2330	void
2331	AddFFRE(FcPattern aPattern, nsCString aFamily, PRBool aWeak)
2332	{
2333	nsCAutoString family;
2334	FFREToFamily(*aFamily, family);
2335
2336	FcValue v;
2337	v.type = FcTypeString;
2338	// casting away the const here, should be safe
2339	v.u.s = (FcChar8 *)family.get();
2340
2341	if (aWeak)
2342	FcPatternAddWeak(aPattern, FC_FAMILY, v, FcTrue);
2343	else
2344	FcPatternAdd(aPattern, FC_FAMILY, v, FcTrue);
2345	}
2346
2347	/* static */
2348	void
2349	FFREToFamily(nsACString &aFFREName, nsACString &oFamily)
2350	{
2351	if (FFRECountHyphens(aFFREName) == 3) {
2352	PRInt32 familyHyphen = aFFREName.FindChar('-') + 1;
2353	PRInt32 registryHyphen = aFFREName.FindChar('-',familyHyphen);
2354	oFamily.Append(Substring(aFFREName, familyHyphen,
2355	registryHyphen-familyHyphen));
2356	}
2357	else {
2358	oFamily.Append(aFFREName);
2359	}
2360	}
2361
2362	/* static */
2363	int
2364	FFRECountHyphens (nsACString &aFFREName)
2365	{
2366	int h = 0;
2367	PRInt32 hyphen = 0;
2368	while ((hyphen = aFFREName.FindChar('-', hyphen)) >= 0) {
2369	++h;
2370	++hyphen;
2371	}
2372	return h;
2373	}
2374
2375	/* static */
2376	int
2377	CompareFontNames (const void* aArg1, const void* aArg2, void* aClosure)	2205	CompareFontNames (const void* aArg1, const void* aArg2, void* aClosure)
2378	{	2206	{
2379	const PRUnichar* str1 = ((const PRUnichar*) aArg1);	2207	const PRUnichar* str1 = ((const PRUnichar*) aArg1);
2380	const PRUnichar* str2 = ((const PRUnichar*) aArg2);	2208	const PRUnichar* str2 = ((const PRUnichar*) aArg2);
2381		2209
2382	return nsCRT::strcmp(str1, str2);	2210	return nsCRT::strcmp(str1, str2);
2383	}	2211	}
2384		2212
2385	PRBool
2386	IsASCIIFontName(const nsString& aName)
2387	{
2388	PRUint32 len = aName.Length();
2389	const PRUnichar* str = aName.get();
2390	for (PRUint32 i = 0; i < len; i++) {
2391	/*
2392	* X font names are printable ASCII, ignore others (for now)
2393	*/
2394	if ((str[i] < 0x20) \|\| (str[i] > 0x7E)) {
2395	return PR_FALSE;
2396	}
2397	}
2398
2399	return PR_TRUE;
2400	}
2401
2402	/* static */	2213	/* static */
2403	nsresult	2214	nsresult
2404	EnumFontsXft(nsIAtom* aLangGroup, const char* aGeneric,	2215	EnumFontsXft(nsIAtom* aLangGroup, const char* aGeneric,
2405	PRUint32* aCount, PRUnichar*** aResult)	2216	PRUint32* aCount, PRUnichar*** aResult)
2406	{	2217	{
2407	FcPattern *pat = NULL;	2218	FcPattern *pat = NULL;
2408	FcObjectSet *os = NULL;	2219	FcObjectSet *os = NULL;
Lines 2422-2436 EnumFontsXft(nsIAtom* aLangGroup, const Link Here
2422		2233
2423	os = FcObjectSetBuild(FC_FAMILY, FC_FOUNDRY, 0);	2234	os = FcObjectSetBuild(FC_FAMILY, FC_FOUNDRY, 0);
2424	if (!os)	2235	if (!os)
2425	goto end;	2236	goto end;
2426		2237
2427	// take the pattern and add the lang group to it	2238	// take the pattern and add the lang group to it
2428	if (aLangGroup)	2239	if (aLangGroup)
2429	AddLangGroup(pat, aLangGroup);	2240	NS_AddLangGroup(pat, aLangGroup);
2430		2241
2431	// get the font list	2242	// get the font list
2432	fs = FcFontList(0, pat, os);	2243	fs = FcFontList(0, pat, os);
2433		2244
2434	if (!fs)	2245	if (!fs)
2435	goto end;	2246	goto end;
2436		2247
Lines 2530-2557 EnumFontsXft(nsIAtom* aLangGroup, const Link Here
2530	if (fs)	2341	if (fs)
2531	FcFontSetDestroy(fs);	2342	FcFontSetDestroy(fs);
2532		2343
2533	return rv;	2344	return rv;
2534	}	2345	}
2535		2346
2536	/* static */	2347	/* static */
2537	const MozXftLangGroup*
2538	FindFCLangGroup (nsACString &aLangGroup)
2539	{
2540	for (unsigned int i=0; i < NUM_XFT_LANG_GROUPS; ++i) {
2541	if (aLangGroup.Equals(MozXftLangGroups[i].mozLangGroup,
2542	nsCaseInsensitiveCStringComparator())) {
2543	return &MozXftLangGroups[i];
2544	}
2545	}
2546
2547	return nsnull;
2548	}
2549
2550	/* static */
2551	void	2348	void
2552	ConvertCharToUCS4(const char *aString, PRUint32 aLength,	2349	ConvertCharToUCS4(const char *aString, PRUint32 aLength,
2553	nsAutoFcChar32Buffer &aOutBuffer, PRUint32 *aOutLen)	2350	nsAutoFcChar32Buffer &aOutBuffer, PRUint32 *aOutLen)
2554	{	2351	{
2555	*aOutLen = 0;	2352	*aOutLen = 0;
2556	FcChar32 *outBuffer;	2353	FcChar32 *outBuffer;
2557		2354

Lines 67-82 Link Here

(-)gfx/src/gtk/nsGfxFactoryGTK.cpp (-2 / +4 lines)
67	#endif	67	#endif
68	#ifdef MOZ_ENABLE_COREXFONTS	68	#ifdef MOZ_ENABLE_COREXFONTS
69	#include "nsFontMetricsGTK.h"	69	#include "nsFontMetricsGTK.h"
70	#endif	70	#endif
71	#include "nsFontMetricsUtils.h"	71	#include "nsFontMetricsUtils.h"
72	#include "nsPrintSession.h"	72	#include "nsPrintSession.h"
73	#include "gfxImageFrame.h"	73	#include "gfxImageFrame.h"
		74	#ifdef MOZ_ENABLE_FREETYPE2
74	#include "nsFT2FontCatalog.h"	75	#include "nsFT2FontCatalog.h"
75	#include "nsFreeType.h"	76	#include "nsFreeType.h"
		77	#endif
76		78
77	// objects that just require generic constructors	79	// objects that just require generic constructors
78		80
79	NS_GENERIC_FACTORY_CONSTRUCTOR(nsDeviceContextGTK)	81	NS_GENERIC_FACTORY_CONSTRUCTOR(nsDeviceContextGTK)
80	NS_GENERIC_FACTORY_CONSTRUCTOR(nsRenderingContextGTK)	82	NS_GENERIC_FACTORY_CONSTRUCTOR(nsRenderingContextGTK)
81	NS_GENERIC_FACTORY_CONSTRUCTOR(nsImageGTK)	83	NS_GENERIC_FACTORY_CONSTRUCTOR(nsImageGTK)
82	NS_GENERIC_FACTORY_CONSTRUCTOR(nsBlender)	84	NS_GENERIC_FACTORY_CONSTRUCTOR(nsBlender)
Lines 88-103 NS_GENERIC_FACTORY_CONSTRUCTOR(nsScreenM Link Here
88	NS_GENERIC_FACTORY_CONSTRUCTOR(nsPrintOptionsGTK)	90	NS_GENERIC_FACTORY_CONSTRUCTOR(nsPrintOptionsGTK)
89	NS_GENERIC_FACTORY_CONSTRUCTOR(nsPrinterEnumeratorGTK)	91	NS_GENERIC_FACTORY_CONSTRUCTOR(nsPrinterEnumeratorGTK)
90	#ifdef NATIVE_THEME_SUPPORT	92	#ifdef NATIVE_THEME_SUPPORT
91	NS_GENERIC_FACTORY_CONSTRUCTOR(nsNativeThemeGTK)	93	NS_GENERIC_FACTORY_CONSTRUCTOR(nsNativeThemeGTK)
92	#endif	94	#endif
93	NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsPrintSession, Init)	95	NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsPrintSession, Init)
94	NS_GENERIC_FACTORY_CONSTRUCTOR(gfxImageFrame)	96	NS_GENERIC_FACTORY_CONSTRUCTOR(gfxImageFrame)
95	NS_GENERIC_FACTORY_CONSTRUCTOR(nsFT2FontCatalog)
96	#ifdef MOZ_ENABLE_FREETYPE2	97	#ifdef MOZ_ENABLE_FREETYPE2
		98	NS_GENERIC_FACTORY_CONSTRUCTOR(nsFT2FontCatalog)
97	NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsFreeType2, Init)	99	NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsFreeType2, Init)
98	#endif	100	#endif
99		101
100	// our custom constructors	102	// our custom constructors
101		103
102	static nsresult	104	static nsresult
103	nsFontMetricsConstructor(nsISupports aOuter, REFNSIID aIID, void *aResult)	105	nsFontMetricsConstructor(nsISupports aOuter, REFNSIID aIID, void *aResult)
Lines 287-305 static const nsModuleComponentInfo compo Link Here
287	GFX_IMAGEFRAME_CID,	289	GFX_IMAGEFRAME_CID,
288	"@mozilla.org/gfx/image/frame;2",	290	"@mozilla.org/gfx/image/frame;2",
289	gfxImageFrameConstructor, },	291	gfxImageFrameConstructor, },
290	{ "Print Session",	292	{ "Print Session",
291	NS_PRINTSESSION_CID,	293	NS_PRINTSESSION_CID,
292	"@mozilla.org/gfx/printsession;1",	294	"@mozilla.org/gfx/printsession;1",
293	nsPrintSessionConstructor },	295	nsPrintSessionConstructor },
		296	#ifdef MOZ_ENABLE_FREETYPE2
294	{ "TrueType Font Catalog Service",	297	{ "TrueType Font Catalog Service",
295	NS_FONTCATALOGSERVICE_CID,	298	NS_FONTCATALOGSERVICE_CID,
296	"@mozilla.org/gfx/xfontcatalogservice;1",	299	"@mozilla.org/gfx/xfontcatalogservice;1",
297	nsFT2FontCatalogConstructor },	300	nsFT2FontCatalogConstructor },
298	#ifdef MOZ_ENABLE_FREETYPE2
299	{ "FreeType2 routines",	301	{ "FreeType2 routines",
300	NS_FREETYPE2_CID,	302	NS_FREETYPE2_CID,
301	NS_FREETYPE2_CONTRACTID,	303	NS_FREETYPE2_CONTRACTID,
302	nsFreeType2Constructor },	304	nsFreeType2Constructor },
303	#endif	305	#endif
304	#ifdef NATIVE_THEME_SUPPORT	306	#ifdef NATIVE_THEME_SUPPORT
305	{ "Native Theme Renderer",	307	{ "Native Theme Renderer",

Lines 73-107 EXTRA_DSO_LDOPTS = \ Link Here

(-)gfx/src/ps/Makefile.in (-5 / +16 lines)
73	-L$(DIST)/lib \	73	-L$(DIST)/lib \
74	-lgfxshared_s \	74	-lgfxshared_s \
75	$(EXTRA_DSO_LIBS) \	75	$(EXTRA_DSO_LIBS) \
76	$(MOZ_COMPONENT_LIBS) \	76	$(MOZ_COMPONENT_LIBS) \
77	$(MOZ_UNICHARUTIL_LIBS) \	77	$(MOZ_UNICHARUTIL_LIBS) \
78	$(NULL)	78	$(NULL)
79		79
80	ifdef MOZ_ENABLE_FREETYPE2	80	ifdef MOZ_ENABLE_XFT
		81	EXTRA_DSO_LDOPTS += \
		82	$(MOZ_XFT_LIBS) \
		83	$(NULL)
		84	endif
		85
		86	ifneq (,$(MOZ_ENABLE_FREETYPE2)$(MOZ_ENABLE_XFT))
81	CPPSRCS += \	87	CPPSRCS += \
82	nsCidMap.cpp \	88	nsCidMap.cpp \
83	nsType1.cpp \	89	nsType1.cpp \
84	nsType8.cpp \	90	nsType8.cpp \
85	$(NULL)	91	$(NULL)
86	endif	92	endif
87		93
88	include $(topsrcdir)/config/rules.mk	94	include $(topsrcdir)/config/rules.mk
89		95
90	ifdef MOZ_ENABLE_FREETYPE2
91	INCLUDES += $(FT2_CFLAGS)
92	endif
93
94	CFLAGS += $(TK_CFLAGS)	96	CFLAGS += $(TK_CFLAGS)
95	CXXFLAGS += $(TK_CFLAGS)	97	CXXFLAGS += $(TK_CFLAGS)
96		98
97	LOCAL_INCLUDES = \	99	LOCAL_INCLUDES = \
98	-I../.. \	100	-I../.. \
99	-I$(srcdir)/.. \	101	-I$(srcdir)/.. \
100	$(NULL)	102	$(NULL)
101		103
		104	ifdef MOZ_ENABLE_XFT
		105	INCLUDES += $(MOZ_XFT_CFLAGS)
		106	LOCAL_INCLUDES += -I$(srcdir)/../shared
		107	else
		108	ifdef MOZ_ENABLE_FREETYPE2
		109	INCLUDES += $(FT2_CFLAGS)
		110	endif
		111	endif
		112
102	libs::	113	libs::
103	$(INSTALL) $(EXPORT_RESOURCE) $(DIST)/bin/res	114	$(INSTALL) $(EXPORT_RESOURCE) $(DIST)/bin/res
104		115
105	install::	116	install::
106	$(SYSINSTALL) $(IFLAGS1) $(EXPORT_RESOURCE) $(DESTDIR)$(mozappdir)/res	117	$(SYSINSTALL) $(IFLAGS1) $(EXPORT_RESOURCE) $(DESTDIR)$(mozappdir)/res
107		118

Lines 209-232 nsDeviceContextPS::InitDeviceContextPS(n Link Here

(-)gfx/src/ps/nsDeviceContextPS.cpp (-1 / +12 lines)
209	mParentDeviceContext = aParentContext;	209	mParentDeviceContext = aParentContext;
210		210
211	mPSFontGeneratorList = new nsHashtable();	211	mPSFontGeneratorList = new nsHashtable();
212	NS_ENSURE_TRUE(mPSFontGeneratorList, NS_ERROR_OUT_OF_MEMORY);	212	NS_ENSURE_TRUE(mPSFontGeneratorList, NS_ERROR_OUT_OF_MEMORY);
213		213
214	nsresult rv;	214	nsresult rv;
215	nsCOMPtr<nsIPref> pref(do_GetService(NS_PREF_CONTRACTID, &rv));	215	nsCOMPtr<nsIPref> pref(do_GetService(NS_PREF_CONTRACTID, &rv));
		216	#ifdef MOZ_ENABLE_XFT
		217	if (NS_SUCCEEDED(rv)) {
		218	rv = pref->GetBoolPref("font.FreeType2.printing", &mFTPEnable);
		219	if (NS_FAILED(rv))
		220	mFTPEnable = PR_FALSE;
		221	}
		222	#else
		223	mFTPEnable = PR_FALSE;
		224	#ifdef MOZ_ENABLE_FREETYPE2
216	if (NS_SUCCEEDED(rv)) {	225	if (NS_SUCCEEDED(rv)) {
217	rv = pref->GetBoolPref("font.FreeType2.enable", &mFTPEnable);	226	rv = pref->GetBoolPref("font.FreeType2.enable", &mFTPEnable);
218	if (NS_FAILED(rv))	227	if (NS_FAILED(rv))
219	mFTPEnable = PR_FALSE;	228	mFTPEnable = PR_FALSE;
220	if (mFTPEnable) {	229	if (mFTPEnable) {
221	rv = pref->GetBoolPref("font.FreeType2.printing", &mFTPEnable);	230	rv = pref->GetBoolPref("font.FreeType2.printing", &mFTPEnable);
222	if (NS_FAILED(rv))	231	if (NS_FAILED(rv))
223	mFTPEnable = PR_FALSE;	232	mFTPEnable = PR_FALSE;
224	}	233	}
225	}	234	}
		235	#endif
		236	#endif
226		237
227	// the user's locale	238	// the user's locale
228	nsCOMPtr<nsILanguageAtomService> langService;	239	nsCOMPtr<nsILanguageAtomService> langService;
229	langService = do_GetService(NS_LANGUAGEATOMSERVICE_CONTRACTID);	240	langService = do_GetService(NS_LANGUAGEATOMSERVICE_CONTRACTID);
230	if (langService) {	241	if (langService) {
231	langService->GetLocaleLanguageGroup(&gUsersLocale);	242	langService->GetLocaleLanguageGroup(&gUsersLocale);
232	}	243	}
Lines 431-445 GeneratePSFontCallback(nsHashKey *aKey, Link Here
431	*/	442	*/
432	NS_IMETHODIMP nsDeviceContextPS::EndDocument(void)	443	NS_IMETHODIMP nsDeviceContextPS::EndDocument(void)
433	{	444	{
434	PR_LOG(nsDeviceContextPSLM, PR_LOG_DEBUG, ("nsDeviceContextPS::EndDocument()\n"));	445	PR_LOG(nsDeviceContextPSLM, PR_LOG_DEBUG, ("nsDeviceContextPS::EndDocument()\n"));
435		446
436	NS_ENSURE_TRUE(mPSObj != nsnull, NS_ERROR_NULL_POINTER);	447	NS_ENSURE_TRUE(mPSObj != nsnull, NS_ERROR_NULL_POINTER);
437		448
438	#ifdef MOZ_ENABLE_FREETYPE2	449	#if defined(MOZ_ENABLE_FREETYPE2) \|\| defined(MOZ_ENABLE_XFT)
439	// Before output Type8 font, check whether printer support CID font	450	// Before output Type8 font, check whether printer support CID font
440	if (mFTPEnable && mPSFontGeneratorList)	451	if (mFTPEnable && mPSFontGeneratorList)
441	if (mPSFontGeneratorList->Count() > 0)	452	if (mPSFontGeneratorList->Count() > 0)
442	mPSObj->add_cid_check();	453	mPSObj->add_cid_check();
443	#endif	454	#endif
444		455
445	/* Core of TrueType printing:	456	/* Core of TrueType printing:

Lines 47-61 Link Here

(-)gfx/src/ps/nsFontMetricsPS.h (-6 / +139 lines)
47	#include "nsIAtom.h"	47	#include "nsIAtom.h"
48	#include "nsUnitConversion.h"	48	#include "nsUnitConversion.h"
49	#include "nsIDeviceContext.h"	49	#include "nsIDeviceContext.h"
50	#include "nsCOMPtr.h"	50	#include "nsCOMPtr.h"
51	#include "nsCRT.h"	51	#include "nsCRT.h"
52	#include "nsCompressedCharMap.h"	52	#include "nsCompressedCharMap.h"
53	#include "nsPostScriptObj.h"	53	#include "nsPostScriptObj.h"
		54	#ifdef MOZ_ENABLE_XFT
		55	#include <ft2build.h>
		56	#include FT_FREETYPE_H
		57	#include FT_GLYPH_H
		58	#include FT_CACHE_H
		59	#include FT_CACHE_IMAGE_H
		60	#include FT_OUTLINE_H
		61	#include FT_OUTLINE_H
		62	#include FT_TRUETYPE_TABLES_H
		63	#else
		64	#ifdef MOZ_ENABLE_FREETYPE2
54	#include "nsIFontCatalogService.h"	65	#include "nsIFontCatalogService.h"
		66	#endif
		67	#endif
55	#include "nsVoidArray.h"	68	#include "nsVoidArray.h"
56	#include "nsHashtable.h"	69	#include "nsHashtable.h"
57		70
58	class nsPSFontGenerator;	71	class nsPSFontGenerator;
59	class nsDeviceContextPS;	72	class nsDeviceContextPS;
60	class nsRenderingContextPS;	73	class nsRenderingContextPS;
61	class nsFontPS;	74	class nsFontPS;
Lines 247-270 public: Link Here
247	#endif	260	#endif
248		261
249	nsAFMObject* mAFMInfo;	262	nsAFMObject* mAFMInfo;
250	PRInt16 mFontIndex;	263	PRInt16 mFontIndex;
251	nsString mFamilyName;	264	nsString mFamilyName;
252	};	265	};
253		266
		267
		268	#ifdef MOZ_ENABLE_XFT
		269
		270	#include <X11/Xft/Xft.h>
		271
		272	class nsXftEntry
		273	{
		274	public:
		275	nsXftEntry(FcPattern *aFontPattern);
		276	~nsXftEntry() {};
		277
		278	FT_Face mFace;
		279	int mFaceIndex;
		280	nsCString mFontFileName;
		281	nsCString mFamilyName;
		282	nsCString mStyleName;
		283
		284	protected:
		285	nsXftEntry() {};
		286	};
		287
		288	struct fontps {
		289	nsXftEntry *entry;
		290	nsFontPS *fontps;
		291	FcCharSet *charset;
		292	};
		293
		294	struct fontPSInfo {
		295	nsVoidArray *fontps;
		296	const nsFont* nsfont;
		297	nsCAutoString lang;
		298	nsHashtable *alreadyLoaded;
		299	nsCStringArray mFontList;
		300	nsAutoVoidArray mFontIsGeneric;
		301	nsCString *mGenericFont;
		302	};
		303
		304	class nsFontPSXft : public nsFontPS
		305	{
		306	public:
		307	static nsFontPS* FindFont(PRUnichar aChar, const nsFont& aFont,
		308	nsFontMetricsPS* aFontMetrics);
		309	nsresult Init(nsXftEntry* aEntry,
		310	nsPSFontGenerator* aPSFontGen);
		311	static PRBool CSSFontEnumCallback(const nsString& aFamily, PRBool aGeneric,
		312	void* aFpi);
		313
		314	nsFontPSXft(const nsFont& aFont, nsFontMetricsPS* aFontMetrics);
		315	virtual ~nsFontPSXft();
		316	NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
		317
		318	nscoord GetWidth(const char* aString, PRUint32 aLength);
		319	nscoord GetWidth(const PRUnichar* aString, PRUint32 aLength);
		320	nscoord DrawString(nsRenderingContextPS* aContext,
		321	nscoord aX, nscoord aY,
		322	const char* aString, PRUint32 aLength);
		323	nscoord DrawString(nsRenderingContextPS* aContext,
		324	nscoord aX, nscoord aY,
		325	const PRUnichar* aString, PRUint32 aLength);
		326	nsresult RealizeFont(nsFontMetricsPS* aFontMetrics, float dev2app);
		327	nsresult SetupFont(nsRenderingContextPS* aContext);
		328
		329	#ifdef MOZ_MATHML
		330	nsresult
331	GetBoundingMetrics(const char* aString,
332	PRUint32 aLength,
333	nsBoundingMetrics& aBoundingMetrics);
334	nsresult
335	GetBoundingMetrics(const PRUnichar* aString,
336	PRUint32 aLength,
337	nsBoundingMetrics& aBoundingMetrics);
338	#endif
339
340	nsXftEntry *mEntry;
341	FT_Face getFTFace();
342
343	protected:
344	PRUint16 mPixelSize;
345	FTC_Image_Desc mImageDesc;
346	FT_Library mFreeTypeLibrary;
347	FTC_Manager mFTCacheManager;
348	FTC_Image_Cache mImageCache;
349
350	int ascent();
351	int descent();
352	PRBool getXHeight(unsigned long &aVal);
353	int max_ascent();
354	int max_descent();
355	int max_width();
356	PRBool superscript_y(long &aVal);
357	PRBool subscript_y(long &aVal);
358	PRBool underlinePosition(long &aVal);
359	PRBool underline_thickness(unsigned long &aVal);
360	nsPSFontGenerator* mPSFontGenerator;
361	};
362
363	#else
364
365	#ifdef MOZ_ENABLE_FREETYPE2
366	#include "nsIFreeType2.h"
367
254	typedef struct {	368	typedef struct {
255	nsITrueTypeFontCatalogEntry *entry;	369	nsITrueTypeFontCatalogEntry *entry;
256	nsFontPS *fontps;	370	nsFontPS *fontps;
257	unsigned short *ccmap;	371	unsigned short *ccmap;
258	} fontps;	372	} fontps;
259		373
260	#ifdef MOZ_ENABLE_FREETYPE2
261
262	#include "nsIFreeType2.h"
263
264	typedef struct {	374	typedef struct {
265	nsVoidArray *fontps;	375	nsVoidArray *fontps;
266	const nsFont* nsfont;	376	const nsFont* nsfont;
267	nsCAutoString lang;	377	nsCAutoString lang;
268	nsHashtable *alreadyLoaded;	378	nsHashtable *alreadyLoaded;
269	PRUint16 slant;	379	PRUint16 slant;
270	PRUint16 weight;	380	PRUint16 weight;
Lines 334-371 protected: Link Here
334	PRBool superscript_y(long &aVal);	444	PRBool superscript_y(long &aVal);
335	PRBool subscript_y(long &aVal);	445	PRBool subscript_y(long &aVal);
336	PRBool underlinePosition(long &aVal);	446	PRBool underlinePosition(long &aVal);
337	PRBool underline_thickness(unsigned long &aVal);	447	PRBool underline_thickness(unsigned long &aVal);
338	nsPSFontGenerator* mPSFontGenerator;	448	nsPSFontGenerator* mPSFontGenerator;
339	};	449	};
340		450
341	#endif	451	#else // !FREETYPE2 && !XFT
		452	typedef struct {
		453	nsFontPS *fontps;
		454	} fontps;
		455	#endif // MOZ_ENABLE_FREETYPE2
		456	#endif // MOZ_ENABLE_XFT
342		457
343	class nsPSFontGenerator {	458	class nsPSFontGenerator {
344	public:	459	public:
345	nsPSFontGenerator();	460	nsPSFontGenerator();
346	virtual ~nsPSFontGenerator();	461	virtual ~nsPSFontGenerator();
347	virtual void GeneratePSFont(FILE* aFile);	462	virtual void GeneratePSFont(FILE* aFile);
348	void AddToSubset(const PRUnichar* aString, PRUint32 aLength);	463	void AddToSubset(const PRUnichar* aString, PRUint32 aLength);
349	void AddToSubset(const char* aString, PRUint32 aLength);	464	void AddToSubset(const char* aString, PRUint32 aLength);
350		465
351	protected:	466	protected:
352	nsString mSubset;	467	nsString mSubset;
353	};	468	};
354		469
		470
		471	#ifdef MOZ_ENABLE_XFT
		472
		473	class nsXftType8Generator : public nsPSFontGenerator {
		474	public:
		475	nsXftType8Generator();
		476	~nsXftType8Generator();
		477	nsresult Init(nsXftEntry* aFce);
		478	void GeneratePSFont(FILE* aFile);
		479
		480	protected:
		481	nsXftEntry *mEntry;
		482	FTC_Image_Desc mImageDesc;
		483	FT_Library mFreeTypeLibrary;
		484	FTC_Manager mFTCacheManager;
		485	};
		486	#else
355	#ifdef MOZ_ENABLE_FREETYPE2	487	#ifdef MOZ_ENABLE_FREETYPE2
356	class nsFT2Type8Generator : public nsPSFontGenerator {	488	class nsFT2Type8Generator : public nsPSFontGenerator {
357	public:	489	public:
358	nsFT2Type8Generator();	490	nsFT2Type8Generator();
359	~nsFT2Type8Generator();	491	~nsFT2Type8Generator();
360	nsresult Init(nsITrueTypeFontCatalogEntry* aFce);	492	nsresult Init(nsITrueTypeFontCatalogEntry* aFce);
361	void GeneratePSFont(FILE* aFile);	493	void GeneratePSFont(FILE* aFile);
362		494
363	protected:	495	protected:
364	nsCOMPtr<nsITrueTypeFontCatalogEntry> mEntry;	496	nsCOMPtr<nsITrueTypeFontCatalogEntry> mEntry;
365	nsCOMPtr<nsIFreeType2> mFt2;	497	nsCOMPtr<nsIFreeType2> mFt2;
366	FTC_Image_Desc mImageDesc;	498	FTC_Image_Desc mImageDesc;
367	};	499	};
368	#endif	500	#endif // MOZ_ENABLE_FREETYPE2
		501	#endif // MOZ_ENABLE_XFT
369		502
370	#endif	503	#endif
371		504

Lines 67-81 Link Here

(-)gfx/src/ps/nsType1.cpp (-5 / +35 lines)
67		67
68	#include "nsType1.h"	68	#include "nsType1.h"
69		69
70	static const PRUint16 type1_encryption_c1 = TYPE1_ENCRYPTION_C1;	70	static const PRUint16 type1_encryption_c1 = TYPE1_ENCRYPTION_C1;
71	static const PRUint16 type1_encryption_c2 = TYPE1_ENCRYPTION_C2;	71	static const PRUint16 type1_encryption_c2 = TYPE1_ENCRYPTION_C2;
72		72
73	typedef struct {	73	typedef struct {
		74	#ifndef MOZ_ENABLE_XFT
74	nsIFreeType2 *ft2;	75	nsIFreeType2 *ft2;
		76	#endif
75	FT_Face face;	77	FT_Face face;
76	int elm_cnt;	78	int elm_cnt;
77	int len;	79	int len;
78	double cur_x;	80	double cur_x;
79	double cur_y;	81	double cur_y;
80	unsigned char *buf;	82	unsigned char *buf;
81	int wmode;	83	int wmode;
Lines 177-201 sideWidthAndBearing(FT_Vector *aEndPt, F Link Here
177	{	179	{
178	int aw = 0;	180	int aw = 0;
179	int ah = 0;	181	int ah = 0;
180	FT_UShort upm = aFti->face->units_per_EM;	182	FT_UShort upm = aFti->face->units_per_EM;
181	FT_GlyphSlot slot;	183	FT_GlyphSlot slot;
182	FT_Glyph glyph;	184	FT_Glyph glyph;
183	FT_BBox bbox;	185	FT_BBox bbox;
184	nsresult rv;
185		186
186	slot = aFti->face->glyph;	187	slot = aFti->face->glyph;
187		188
188	rv = aFti->ft2->GetGlyph(slot, &glyph);	189	#ifdef MOZ_ENABLE_XFT
		190	FT_Error error = FT_Get_Glyph(slot, &glyph);
		191	if (error) {
		192	NS_ERROR("sideWidthAndBearing failed to get glyph");
		193	return PR_FALSE;
		194	}
		195	FT_Glyph_Get_CBox(glyph, ft_glyph_bbox_unscaled, &bbox);
		196	#else
		197	nsresult rv = aFti->ft2->GetGlyph(slot, &glyph);
189	if (NS_FAILED(rv)) {	198	if (NS_FAILED(rv)) {
190	NS_ERROR("sideWidthAndBearing failed to get glyph");	199	NS_ERROR("sideWidthAndBearing failed to get glyph");
191	return PR_FALSE;	200	return PR_FALSE;
192	}	201	}
193	aFti->ft2->GlyphGetCBox(glyph, ft_glyph_bbox_unscaled, &bbox);	202	aFti->ft2->GlyphGetCBox(glyph, ft_glyph_bbox_unscaled, &bbox);
194		203	#endif
195		204
196	if (aFti->wmode == 0)	205	if (aFti->wmode == 0)
197	aw = toCS(upm, slot->metrics.horiAdvance);	206	aw = toCS(upm, slot->metrics.horiAdvance);
198	else	207	else
199	aw = -toCS(upm, slot->metrics.vertAdvance);	208	aw = -toCS(upm, slot->metrics.vertAdvance);
200		209
201	if (aEndPt->y == 0) {	210	if (aEndPt->y == 0) {
Lines 367-418 static FT_Outline_Funcs ft_outline_funcs Link Here
367	conicto,	376	conicto,
368	cubicto,	377	cubicto,
369	0,	378	0,
370	0	379	0
371	};	380	};
372		381
373	FT_Error	382	FT_Error
		383	#ifdef MOZ_ENABLE_XFT
		384	FT2GlyphToType1CharString(FT_Face aFace, PRUint32 aGlyphID,
		385	int aWmode, int aLenIV, unsigned char *aBuf)
		386	#else
374	FT2GlyphToType1CharString(nsIFreeType2 *aFt2, FT_Face aFace, PRUint32 aGlyphID,	387	FT2GlyphToType1CharString(nsIFreeType2 *aFt2, FT_Face aFace, PRUint32 aGlyphID,
375	int aWmode, int aLenIV, unsigned char *aBuf)	388	int aWmode, int aLenIV, unsigned char *aBuf)
		389	#endif
376	{	390	{
377	int j;	391	int j;
378	FT_Int32 flags = FT_LOAD_NO_BITMAP \| FT_LOAD_NO_SCALE \| FT_LOAD_NO_HINTING;	392	FT_Int32 flags = FT_LOAD_NO_BITMAP \| FT_LOAD_NO_SCALE \| FT_LOAD_NO_HINTING;
379	FT_GlyphSlot slot;	393	FT_GlyphSlot slot;
380	unsigned char *start = aBuf;	394	unsigned char *start = aBuf;
381	FT2PT1_info fti;	395	FT2PT1_info fti;
382	nsresult rv;
383		396
384	rv = aFt2->LoadGlyph(aFace, aGlyphID, flags);	397	#ifdef MOZ_ENABLE_XFT
		398	FT_Error error = FT_Load_Glyph(aFace, aGlyphID, flags);
		399	if (error) {
		400	NS_ERROR("failed to load aGlyphID");
		401	return error;
		402	}
		403	#else
		404	nsresult rv = aFt2->LoadGlyph(aFace, aGlyphID, flags);
385	if (NS_FAILED(rv)) {	405	if (NS_FAILED(rv)) {
386	NS_ERROR("failed to load aGlyphID");	406	NS_ERROR("failed to load aGlyphID");
387	return 1;	407	return 1;
388	}	408	}
		409	#endif
389	slot = aFace->glyph;	410	slot = aFace->glyph;
390		411
391	if (slot->format != ft_glyph_format_outline) {	412	if (slot->format != ft_glyph_format_outline) {
392	NS_ERROR("aGlyphID is not an outline glyph");	413	NS_ERROR("aGlyphID is not an outline glyph");
393	return 1;	414	return 1;
394	}	415	}
395		416
		417	#ifndef MOZ_ENABLE_XFT
396	fti.ft2 = aFt2;	418	fti.ft2 = aFt2;
		419	#endif
397	fti.face = aFace;	420	fti.face = aFace;
398	fti.buf = aBuf;	421	fti.buf = aBuf;
399	fti.elm_cnt = 0;	422	fti.elm_cnt = 0;
400	fti.len = 0;	423	fti.len = 0;
401	fti.wmode = aWmode;	424	fti.wmode = aWmode;
402		425
403	/* add space for "random" bytes */	426	/* add space for "random" bytes */
404	for (j=0; j< aLenIV; j++) {	427	for (j=0; j< aLenIV; j++) {
405	fti.len += ecsi(&fti.buf, 0);	428	fti.len += ecsi(&fti.buf, 0);
406	}	429	}
		430	#ifdef MOZ_ENABLE_XFT
		431	if (FT_Outline_Decompose(&slot->outline, &ft_outline_funcs, &fti)) {
		432	NS_ERROR("error decomposing aGlyphID");
		433	return 1;
		434	}
		435	#else
407	rv = aFt2->OutlineDecompose(&slot->outline, &ft_outline_funcs, &fti);	436	rv = aFt2->OutlineDecompose(&slot->outline, &ft_outline_funcs, &fti);
408	if (NS_FAILED(rv)) {	437	if (NS_FAILED(rv)) {
409	NS_ERROR("error decomposing aGlyphID");	438	NS_ERROR("error decomposing aGlyphID");
410	return 1;	439	return 1;
411	}	440	}
		441	#endif
412		442
413	if (fti.elm_cnt) {	443	if (fti.elm_cnt) {
414	fti.len += csc(&fti.buf, T1_CLOSEPATH);	444	fti.len += csc(&fti.buf, T1_CLOSEPATH);
415	fti.len += csc(&fti.buf, T1_ENDCHAR);	445	fti.len += csc(&fti.buf, T1_ENDCHAR);
416	}	446	}
417	else {	447	else {
418	FT_Vector end_pt;	448	FT_Vector end_pt;

Lines 50-64 Link Here

(-)gfx/src/ps/nsType1.h (+12 lines)
50	//	50	//
51		51
52	#ifndef TYPE1_H	52	#ifndef TYPE1_H
53	#define TYPE1_H	53	#define TYPE1_H
54		54
55	#include <stdio.h>	55	#include <stdio.h>
56	#include "nspr.h"	56	#include "nspr.h"
		57	#ifdef MOZ_ENABLE_XFT
		58	#include "nsISupports.h"
		59	#include <ft2build.h>
		60	#include FT_FREETYPE_H
		61	#include FT_GLYPH_H
		62	#include FT_OUTLINE_H
		63	#else
57	#include "nsIFreeType2.h"	64	#include "nsIFreeType2.h"
		65	#endif
58		66
59	/* to/from Character Space */	67	/* to/from Character Space */
60	inline int	68	inline int
61	toCS(double upm, double x)	69	toCS(double upm, double x)
62	{	70	{
63	return (int)((x*1000.0)/upm);	71	return (int)((x*1000.0)/upm);
64	}	72	}
Lines 91-102 fromCS(double upm, double x) Link Here
91	/* the 2 byte (escaped) Postscript Type 1 commands */	99	/* the 2 byte (escaped) Postscript Type 1 commands */
92	#define T1_ESC_SBW 7 /* 0x07 */	100	#define T1_ESC_SBW 7 /* 0x07 */
93		101
94	#define TYPE1_ENCRYPTION_KEY 4330	102	#define TYPE1_ENCRYPTION_KEY 4330
95	#define TYPE1_ENCRYPTION_C1 52845	103	#define TYPE1_ENCRYPTION_C1 52845
96	#define TYPE1_ENCRYPTION_C2 22719	104	#define TYPE1_ENCRYPTION_C2 22719
97		105
		106	#ifdef MOZ_ENABLE_XFT
		107	FT_Error FT2GlyphToType1CharString(FT_Face aFace,
		108	#else /* MOZ_ENABLE_FREETYPE2 */
98	FT_Error FT2GlyphToType1CharString(nsIFreeType2 *aFt2, FT_Face aFace,	109	FT_Error FT2GlyphToType1CharString(nsIFreeType2 *aFt2, FT_Face aFace,
		110	#endif
99	PRUint32 aGlyphID, int aWmode, int aLenIV,	111	PRUint32 aGlyphID, int aWmode, int aLenIV,
100	unsigned char *aBuf);	112	unsigned char *aBuf);
101		113
102	#endif /* TYPE1_H */	114	#endif /* TYPE1_H */

Lines 49-77 Link Here

(-)gfx/src/ps/nsType8.cpp (+37 lines)
49		49
50	#include <string.h>	50	#include <string.h>
51	#include <unistd.h>	51	#include <unistd.h>
52		52
53	#include "nsCidMap.h"	53	#include "nsCidMap.h"
54	#include "nsType1.h"	54	#include "nsType1.h"
55	#include "nsType8.h"	55	#include "nsType8.h"
		56	#ifndef MOZ_ENABLE_XFT
56	#include "nsIFreeType2.h"	57	#include "nsIFreeType2.h"
		58	#endif
57	#include "nsIServiceManager.h"	59	#include "nsIServiceManager.h"
58	#include "nsISignatureVerifier.h"	60	#include "nsISignatureVerifier.h"
59	#include "plbase64.h"	61	#include "plbase64.h"
60	#include "nsCRT.h"	62	#include "nsCRT.h"
61		63
62	#define DEFAULT_CMAP_SIZE 10240	64	#define DEFAULT_CMAP_SIZE 10240
63		65
64	#define HEXASCII_LINE_LEN 64	66	#define HEXASCII_LINE_LEN 64
65		67
66		68
67	static void hex_out(unsigned char buf, PRUint32 n, FILE f, PRUint32 *pos);	69	static void hex_out(unsigned char buf, PRUint32 n, FILE f, PRUint32 *pos);
68		70
69	static void flatten_name(char *aToName);	71	static void flatten_name(char *aToName);
		72	#ifdef MOZ_ENABLE_XFT
		73	static int FT2SubsetToCidKeyedType1(FT_Face aFace,
		74	#else
70	static int FT2SubsetToCidKeyedType1(nsIFreeType2 *aFt2, FT_Face aFace,	75	static int FT2SubsetToCidKeyedType1(nsIFreeType2 *aFt2, FT_Face aFace,
		76	#endif
71	const PRUnichar *aCharIDs, int aLen,	77	const PRUnichar *aCharIDs, int aLen,
72	const char *aFontName,	78	const char *aFontName,
73	const char *aRegistry,	79	const char *aRegistry,
74	const char *aEncoding, int aSupplement,	80	const char *aEncoding, int aSupplement,
75	int aWmode, int aLenIV, FILE *aFile);	81	int aWmode, int aLenIV, FILE *aFile);
76		82
77	void	83	void
Lines 315-334 FT2SubsetToType8(FT_Face aFace, const PR Link Here
315	char *encoding = NULL;	321	char *encoding = NULL;
316	int supplement, lenIV;	322	int supplement, lenIV;
317	PRUint32 CIDs_buf[5000];	323	PRUint32 CIDs_buf[5000];
318	PRUint32 *CIDs = CIDs_buf;	324	PRUint32 *CIDs = CIDs_buf;
319	int cmap_type = 0;	325	int cmap_type = 0;
320	PRBool status = PR_FALSE;	326	PRBool status = PR_FALSE;
321		327
		328	#ifndef MOZ_ENABLE_XFT
322	nsresult rv;	329	nsresult rv;
323	nsCOMPtr<nsIFreeType2> ft2 = do_GetService(NS_FREETYPE2_CONTRACTID, &rv);	330	nsCOMPtr<nsIFreeType2> ft2 = do_GetService(NS_FREETYPE2_CONTRACTID, &rv);
324	if (NS_FAILED(rv)) {	331	if (NS_FAILED(rv)) {
325	NS_ERROR("Failed to get nsIFreeType2 service");	332	NS_ERROR("Failed to get nsIFreeType2 service");
326	goto done;	333	goto done;
327	}	334	}
		335	#endif
328		336
329	if ((aNumChars+1) > sizeof(CIDs_buf)/sizeof(CIDs_buf[0]))	337	if ((aNumChars+1) > sizeof(CIDs_buf)/sizeof(CIDs_buf[0]))
330	CIDs = (PRUint32 )PR_Malloc((aNumChars+1)sizeof(CIDs_buf[0]));	338	CIDs = (PRUint32 )PR_Malloc((aNumChars+1)sizeof(CIDs_buf[0]));
331	if (!CIDs) {	339	if (!CIDs) {
332	NS_ERROR("Failed to alloc space for CIDs");	340	NS_ERROR("Failed to alloc space for CIDs");
333	goto done;	341	goto done;
334	}	342	}
Lines 364-378 FT2SubsetToType8(FT_Face aFace, const PR Link Here
364	WriteCmapHeader(cmapname, registry, encoding, supplement, cmap_type, aWmode,	372	WriteCmapHeader(cmapname, registry, encoding, supplement, cmap_type, aWmode,
365	aFile);	373	aFile);
366	WriteCodeSpaceRangeMapUCS2(aFile);	374	WriteCodeSpaceRangeMapUCS2(aFile);
367	WriteCidCharMap(aCharIDs, CIDs, aNumChars, aFile);	375	WriteCidCharMap(aCharIDs, CIDs, aNumChars, aFile);
368	WriteCmapFooter(aFile);	376	WriteCmapFooter(aFile);
369		377
370	/* output the Type 8 CID font */	378	/* output the Type 8 CID font */
		379	#ifdef MOZ_ENABLE_XFT
		380	FT2SubsetToCidKeyedType1(aFace, aCharIDs, aNumChars, fontname,
		381	#else
371	FT2SubsetToCidKeyedType1(ft2, aFace, aCharIDs, aNumChars, fontname,	382	FT2SubsetToCidKeyedType1(ft2, aFace, aCharIDs, aNumChars, fontname,
		383	#endif
372	registry, encoding, supplement, aWmode, lenIV,	384	registry, encoding, supplement, aWmode, lenIV,
373	aFile);	385	aFile);
374	fprintf(aFile, "\n");	386	fprintf(aFile, "\n");
375		387
376	/* compose the cmap and font */	388	/* compose the cmap and font */
377	fprintf(aFile, "/%s\n", cidfontname);	389	fprintf(aFile, "/%s\n", cidfontname);
378	fprintf(aFile, " /%s /CMap findresource\n", cmapname);	390	fprintf(aFile, " /%s /CMap findresource\n", cmapname);
Lines 388-402 done: Link Here
388	PR_FREEIF(cidfontname);	400	PR_FREEIF(cidfontname);
389	if (CIDs != CIDs_buf)	401	if (CIDs != CIDs_buf)
390	PR_Free(CIDs);	402	PR_Free(CIDs);
391	return status;	403	return status;
392	}	404	}
393		405
394	static PRBool	406	static PRBool
		407	#ifdef MOZ_ENABLE_XFT
		408	FT2SubsetToCidKeyedType1(FT_Face aFace,
		409	#else
395	FT2SubsetToCidKeyedType1(nsIFreeType2 *aFt2, FT_Face aFace,	410	FT2SubsetToCidKeyedType1(nsIFreeType2 *aFt2, FT_Face aFace,
		411	#endif
396	const PRUnichar *aCharIDs,	412	const PRUnichar *aCharIDs,
397	int aLen, const char *aFontName,	413	int aLen, const char *aFontName,
398	const char aRegistry, const char aEncoding,	414	const char aRegistry, const char aEncoding,
399	int aSupplement, int aWmode, int aLenIV, FILE *aFile)	415	int aSupplement, int aWmode, int aLenIV, FILE *aFile)
400	{	416	{
401	int i, charstrings_len, data_offset;	417	int i, charstrings_len, data_offset;
402	unsigned int charstring_len;	418	unsigned int charstring_len;
Lines 441-464 FT2SubsetToCidKeyedType1(nsIFreeType2 *a Link Here
441	toCS(upm, aFace->bbox.yMin),	457	toCS(upm, aFace->bbox.yMin),
442	toCS(upm, aFace->bbox.xMax),	458	toCS(upm, aFace->bbox.xMax),
443	toCS(upm, aFace->bbox.yMax));	459	toCS(upm, aFace->bbox.yMax));
444		460
445	fprintf(aFile, "\n");	461	fprintf(aFile, "\n");
446		462
447	/* measure the notdef glyph length */	463	/* measure the notdef glyph length */
		464	#ifdef MOZ_ENABLE_XFT
		465	cmapinfo[0] = FT2GlyphToType1CharString(aFace, 0, aWmode, aLenIV, NULL);
		466	#else
448	cmapinfo[0] = FT2GlyphToType1CharString(aFt2, aFace, 0, aWmode, aLenIV, NULL);	467	cmapinfo[0] = FT2GlyphToType1CharString(aFt2, aFace, 0, aWmode, aLenIV, NULL);
		468	#endif
449	num_charstrings = 1;	469	num_charstrings = 1;
450	charstrings_len = cmapinfo[0];	470	charstrings_len = cmapinfo[0];
451		471
452	/* get charstring lengths */	472	/* get charstring lengths */
453	max_charstring = cmapinfo[0];	473	max_charstring = cmapinfo[0];
454	for (i=0; i<aLen; i++) {	474	for (i=0; i<aLen; i++) {
		475	#ifdef MOZ_ENABLE_XFT
		476	glyphID = FT_Get_Char_Index(aFace, aCharIDs[i]);
		477	cmapinfo[i+1] = FT2GlyphToType1CharString(aFace, glyphID, aWmode,
		478	aLenIV, NULL);
		479	#else
455	aFt2->GetCharIndex(aFace, aCharIDs[i], &glyphID);	480	aFt2->GetCharIndex(aFace, aCharIDs[i], &glyphID);
456	cmapinfo[i+1] = FT2GlyphToType1CharString(aFt2, aFace, glyphID, aWmode,	481	cmapinfo[i+1] = FT2GlyphToType1CharString(aFt2, aFace, glyphID, aWmode,
457	aLenIV, NULL);	482	aLenIV, NULL);
		483	#endif
458	charstrings_len += cmapinfo[i+1];	484	charstrings_len += cmapinfo[i+1];
459	if (cmapinfo[i+1])	485	if (cmapinfo[i+1])
460	num_charstrings++;	486	num_charstrings++;
461	if (cmapinfo[i+1] > max_charstring)	487	if (cmapinfo[i+1] > max_charstring)
462	max_charstring = cmapinfo[i+1];	488	max_charstring = cmapinfo[i+1];
463	}	489	}
464	cmapinfo[i+1] = 0;	490	cmapinfo[i+1] = 0;
Lines 550-572 FT2SubsetToCidKeyedType1(nsIFreeType2 *a Link Here
550	data_offset += cmapinfo[i];	576	data_offset += cmapinfo[i];
551	}	577	}
552		578
553	//	579	//
554	// output the charStrings	580	// output the charStrings
555	//	581	//
556	// output the notdef glyph	582	// output the notdef glyph
		583	#ifdef MOZ_ENABLE_XFT
		584	charstring_len = FT2GlyphToType1CharString(aFace, 0, aWmode, aLenIV,
		585	charstring);
		586	#else
557	charstring_len = FT2GlyphToType1CharString(aFt2, aFace, 0, aWmode, aLenIV,	587	charstring_len = FT2GlyphToType1CharString(aFt2, aFace, 0, aWmode, aLenIV,
558	charstring);	588	charstring);
		589	#endif
559	hex_out(charstring, charstring_len, aFile, &line_pos);	590	hex_out(charstring, charstring_len, aFile, &line_pos);
560		591
561	/* output the charstrings for the glyphs */	592	/* output the charstrings for the glyphs */
562	for (i=0; i<aLen; i++) {	593	for (i=0; i<aLen; i++) {
		594	#ifdef MOZ_ENABLE_XFT
		595	glyphID = FT_Get_Char_Index(aFace, aCharIDs[i]);
		596	charstring_len = FT2GlyphToType1CharString(aFace, glyphID, aWmode,
		597	aLenIV, charstring);
		598	#else
563	aFt2->GetCharIndex(aFace, aCharIDs[i], &glyphID);	599	aFt2->GetCharIndex(aFace, aCharIDs[i], &glyphID);
564	charstring_len = FT2GlyphToType1CharString(aFt2, aFace, glyphID, aWmode,	600	charstring_len = FT2GlyphToType1CharString(aFt2, aFace, glyphID, aWmode,
565	aLenIV, charstring);	601	aLenIV, charstring);
		602	#endif
566	NS_ASSERTION(charstring_len==cmapinfo[i+1], "glyph data changed");	603	NS_ASSERTION(charstring_len==cmapinfo[i+1], "glyph data changed");
567	hex_out(charstring, charstring_len, aFile, &line_pos);	604	hex_out(charstring, charstring_len, aFile, &line_pos);
568	}	605	}
569	// add one byte padding so the interperter can always do 2 byte reads	606	// add one byte padding so the interperter can always do 2 byte reads
570	charstring[0] = 0;	607	charstring[0] = 0;
571	hex_out(charstring, 1, aFile, &line_pos);	608	hex_out(charstring, 1, aFile, &line_pos);
572		609

Lines 39-53 Link Here

(-)gfx/src/ps/nsType8.h (+17 lines)
39	* *** END LICENSE BLOCK *** */	39	* *** END LICENSE BLOCK *** */
40		40
41	#ifndef TYPE8_H	41	#ifndef TYPE8_H
42	#define TYPE8_H	42	#define TYPE8_H
43		43
44	#include <stdio.h>	44	#include <stdio.h>
45	#include "nspr.h"	45	#include "nspr.h"
		46	#ifdef MOZ_ENABLE_XFT
		47	#include <ft2build.h>
		48	#include FT_FREETYPE_H
		49	#include FT_GLYPH_H
		50	#include FT_CACHE_H
		51	#include FT_CACHE_IMAGE_H
		52	#include FT_OUTLINE_H
		53	// macros to handle FreeType2 26.6 numbers (26 bit number with 6 bit fraction)
		54	#define FT_REG_TO_16_16(x) ((x)<<16)
		55	#ifndef FT_MulFix
		56	#define FT_MulFix(v, s) (((v)*(s))>>16)
		57	#endif
		58	#define FT_ROUND(x) (((x) + 32) & ~63) // 63 = 2^6 - 1
		59	#define FT_TRUNC(x) ((x) >> 6)
		60	#define FT_DESIGN_UNITS_TO_PIXELS(v, s) FT_TRUNC(FT_ROUND(FT_MulFix((v) , (s))))
		61	#else /* MOZ_ENABLE_FREETYPE2 */
46	#include "nsIFreeType2.h"	62	#include "nsIFreeType2.h"
		63	#endif /* MOZ_ENABLE_XFT */
47		64
48	void AddCIDCheckCode(FILE *aFile);	65	void AddCIDCheckCode(FILE *aFile);
49	PRBool FT2SubsetToType8(FT_Face aFace, const PRUnichar *aCharIDs,	66	PRBool FT2SubsetToType8(FT_Face aFace, const PRUnichar *aCharIDs,
50	PRUint32 aNumChars, int aWmode, FILE *aFile);	67	PRUint32 aNumChars, int aWmode, FILE *aFile);
51	char* FT2ToType8CidFontName(FT_Face aFace, int aWmode);	68	char* FT2ToType8CidFontName(FT_Face aFace, int aWmode);
52		69
53		70

Lines 93-103 Link Here

(-)gfx/src/x11shared/nsFontDebug.h (+2 lines)
93	fflush(stdout); \	93	fflush(stdout); \
94	} \	94	} \
95	PR_END_MACRO	95	PR_END_MACRO
96		96
97	#define FREETYPE_FONT_PRINTF(x) \	97	#define FREETYPE_FONT_PRINTF(x) \
98	DEBUG_PRINTF_MACRO(x, NS_FONT_DEBUG_FREETYPE_FONT)	98	DEBUG_PRINTF_MACRO(x, NS_FONT_DEBUG_FREETYPE_FONT)
99		99
		100	#ifdef MOZ_ENABLE_FREETYPE2
100	extern PRUint32 gFontDebug;	101	extern PRUint32 gFontDebug;
		102	#endif
101		103
102	#endif	104	#endif
103		105

Lines 52-66 Link Here

(-)gfx/src/xlib/nsFontMetricsXlib.h (-9 / +9 lines)
52	#include "nsCRT.h"	52	#include "nsCRT.h"
53	#include "nsCOMPtr.h"	53	#include "nsCOMPtr.h"
54	#include "nsRenderingContextXlib.h"	54	#include "nsRenderingContextXlib.h"
55	#include "nsICharRepresentable.h"	55	#include "nsICharRepresentable.h"
56	#include "nsCompressedCharMap.h"	56	#include "nsCompressedCharMap.h"
57		57
58	/* Undefine some CPP symbols which wrap not-yet-implemented code */	58	/* Undefine some CPP symbols which wrap not-yet-implemented code */
59	#undef USE_FREETYPE	59	#undef MOZ_ENABLE_FREETYPE2
60	#undef USE_AASB	60	#undef USE_AASB
61	#undef USE_X11SHARED_CODE	61	#undef USE_X11SHARED_CODE
62		62
63	#ifdef USE_X11SHARED_CODE	63	#ifdef USE_X11SHARED_CODE
64	/* XXX: I wish I would use the code in gfx/src/x11shared/ - unfortunately	64	/* XXX: I wish I would use the code in gfx/src/x11shared/ - unfortunately
65	* it is full of GDK/GTK+ dependices which makes it impossible to use it	65	* it is full of GDK/GTK+ dependices which makes it impossible to use it
66	* yet... ;-(	66	* yet... ;-(
Lines 183-216 struct nsFontCharSetXlib; Link Here
183	struct nsFontFamilyXlib;	183	struct nsFontFamilyXlib;
184	struct nsFontNodeXlib;	184	struct nsFontNodeXlib;
185	struct nsFontStretchXlib;	185	struct nsFontStretchXlib;
186	struct nsFontWeightXlib;	186	struct nsFontWeightXlib;
187		187
188	class nsFontXlibUserDefined;	188	class nsFontXlibUserDefined;
189	class nsFontMetricsXlib;	189	class nsFontMetricsXlib;
190	#ifdef USE_FREETYPE	190	#ifdef MOZ_ENABLE_FREETYPE2
191	class nsFreeTypeFace;	191	class nsFreeTypeFace;
192	#endif /* USE_FREETYPE */	192	#endif /* MOZ_ENABLE_FREETYPE2 */
193		193
194	struct nsFontStretchXlib	194	struct nsFontStretchXlib
195	{	195	{
196	NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW	196	NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
197		197
198	void SortSizes(void);	198	void SortSizes(void);
199		199
200	nsFontXlib **mSizes;	200	nsFontXlib **mSizes;
201	PRUint16 mSizesAlloc;	201	PRUint16 mSizesAlloc;
202	PRUint16 mSizesCount;	202	PRUint16 mSizesCount;
203		203
204	char* mScalable;	204	char* mScalable;
205	PRBool mOutlineScaled;	205	PRBool mOutlineScaled;
206	nsVoidArray mScaledFonts;	206	nsVoidArray mScaledFonts;
207	#ifdef USE_FREETYPE	207	#ifdef MOZ_ENABLE_FREETYPE2
208	nsFreeTypeFace *mFreeTypeFaceID;	208	nsFreeTypeFace *mFreeTypeFaceID;
209	#endif /* USE_FREETYPE */	209	#endif /* MOZ_ENABLE_FREETYPE2 */
210	};	210	};
211		211
212	struct nsFontStyleXlib	212	struct nsFontStyleXlib
213	{	213	{
214	NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW	214	NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
215		215
216	void FillWeightHoles(void);	216	void FillWeightHoles(void);
Lines 285-301 public: Link Here
285		285
286	inline int SupportsChar(PRUnichar aChar)	286	inline int SupportsChar(PRUnichar aChar)
287	{ return mCCMap && CCMAP_HAS_CHAR(mCCMap, aChar); };	287	{ return mCCMap && CCMAP_HAS_CHAR(mCCMap, aChar); };
288		288
289	virtual XFontStruct *GetXFontStruct(void);	289	virtual XFontStruct *GetXFontStruct(void);
290	virtual nsXFont *GetXFont(void);	290	virtual nsXFont *GetXFont(void);
291	virtual PRBool GetXFontIs10646(void);	291	virtual PRBool GetXFontIs10646(void);
292	#ifdef USE_FREETYPE	292	#ifdef MOZ_ENABLE_FREETYPE2
293	virtual PRBool IsFreeTypeFont(void);	293	virtual PRBool IsFreeTypeFont(void);
294	#endif /* USE_FREETYPE */	294	#endif /* MOZ_ENABLE_FREETYPE2 */
295	virtual int GetWidth(const PRUnichar* aString, PRUint32 aLength) = 0;	295	virtual int GetWidth(const PRUnichar* aString, PRUint32 aLength) = 0;
296	virtual int DrawString(nsRenderingContextXlib *aContext,	296	virtual int DrawString(nsRenderingContextXlib *aContext,
297	nsIDrawingSurfaceXlib *aSurface, nscoord aX,	297	nsIDrawingSurfaceXlib *aSurface, nscoord aX,
298	nscoord aY, const PRUnichar* aString,	298	nscoord aY, const PRUnichar* aString,
299	PRUint32 aLength) = 0;	299	PRUint32 aLength) = 0;
300	#ifdef MOZ_MATHML	300	#ifdef MOZ_MATHML
301	// bounding metrics for a string	301	// bounding metrics for a string
Lines 472-486 public: Link Here
472		472
473	class nsHashKey;	473	class nsHashKey;
474		474
475	/* XXX: We can't include gfx/src/x11shared/nsFreeType.h because it relies on	475	/* XXX: We can't include gfx/src/x11shared/nsFreeType.h because it relies on
476	* GDK/GTK+ includes which are not available in Xlib builds (fix is to remove	476	* GDK/GTK+ includes which are not available in Xlib builds (fix is to remove
477	* the GDK/GTK+ dependicy from the code in gfx/src/x11shared/ ...)	477	* the GDK/GTK+ dependicy from the code in gfx/src/x11shared/ ...)
478	*/	478	*/
479	#ifndef USE_FREETYPE	479	#ifndef MOZ_ENABLE_FREETYPE2
480	/*	480	/*
481	* Defines for the TrueType codepage bits.	481	* Defines for the TrueType codepage bits.
482	* Used as a hint for the languages supported in a TrueType font.	482	* Used as a hint for the languages supported in a TrueType font.
483	*/	483	*/
484		484
485	/*	485	/*
486	* ulCodePageRange1	486	* ulCodePageRange1
Lines 521-531 class nsHashKey; Link Here
521	#define TT_OS2_CPR2_CYRILLIC (0x02000000)/IBM Cyrillic; primarily Russian/	521	#define TT_OS2_CPR2_CYRILLIC (0x02000000)/IBM Cyrillic; primarily Russian/
522	#define TT_OS2_CPR2_LATIN2 (0x04000000) /* Latin 2 */	522	#define TT_OS2_CPR2_LATIN2 (0x04000000) /* Latin 2 */
523	#define TT_OS2_CPR2_BALTIC (0x08000000) /* MS-DOS Baltic */	523	#define TT_OS2_CPR2_BALTIC (0x08000000) /* MS-DOS Baltic */
524	#define TT_OS2_CPR2_GREEK_437G (0x10000000) /* Greek; former 437 G */	524	#define TT_OS2_CPR2_GREEK_437G (0x10000000) /* Greek; former 437 G */
525	#define TT_OS2_CPR2_ARABIC_708 (0x20000000) /* Arabic; ASMO 708 */	525	#define TT_OS2_CPR2_ARABIC_708 (0x20000000) /* Arabic; ASMO 708 */
526	#define TT_OS2_CPR2_WE_LATIN1 (0x40000000) /* WE/Latin 1 */	526	#define TT_OS2_CPR2_WE_LATIN1 (0x40000000) /* WE/Latin 1 */
527	#define TT_OS2_CPR2_US (0x80000000) /* US */	527	#define TT_OS2_CPR2_US (0x80000000) /* US */
528	#endif /* !USE_FREETYPE */	528	#endif /* !MOZ_ENABLE_FREETYPE2 */
529		529
530	#endif /* !nsFontMetricsXlib_h__ */	530	#endif /* !nsFontMetricsXlib_h__ */
531		531

Added Link Here

(-)gfx/src/shared/nsFontConfigUtils.cpp (+227 lines)
1	/* -- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -- */
2	/* *** BEGIN LICENSE BLOCK ***
3	* Version: MPL 1.1/GPL 2.0/LGPL 2.1
4	*
5	* The contents of this file are subject to the Mozilla Public License Version
6	* 1.1 (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at
8	* http://www.mozilla.org/MPL/
9	*
10	* Software distributed under the License is distributed on an "AS IS" basis,
11	* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12	* for the specific language governing rights and limitations under the
13	* License.
14	*
15	* The Original Code is mozilla.org code.
16	*
17	* The Initial Developer of the Original Code is Christopher Blizzard
18	* <blizzard@mozilla.org>. Portions created by the Initial Developer
19	* are Copyright (C) 2002 the Initial Developer. All Rights Reserved.
20	*
21	* Contributor(s):
22	*
23	* Alternatively, the contents of this file may be used under the terms of
24	* either of the GNU General Public License Version 2 or later (the "GPL"),
25	* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
26	* in which case the provisions of the GPL or the LGPL are applicable instead
27	* of those above. If you wish to allow use of your version of this file only
28	* under the terms of either the GPL or the LGPL, and not to allow others to
29	* use your version of this file under the terms of the MPL, indicate your
30	* decision by deleting the provisions above and replace them with the notice
31	* and other provisions required by the GPL or the LGPL. If you do not delete
32	* the provisions above, a recipient may use your version of this file under
33	* the terms of any one of the MPL, the GPL or the LGPL.
34	*
35	* *** END LICENSE BLOCK *** */
36
37	#include "nsFontConfigUtils.h"
38
39	struct MozXftLangGroup {
40	const char *mozLangGroup;
41	FcChar32 character;
42	const FcChar8 *XftLang;
43	};
44
45	const MozXftLangGroup MozXftLangGroups[] = {
46	{ "x-western", 0x0041, (const FcChar8 *)"en" },
47	{ "x-central-euro", 0x0100, (const FcChar8 *)"pl" },
48	{ "x-cyrillic", 0x0411, (const FcChar8 *)"ru" },
49	{ "x-baltic", 0x0104, (const FcChar8 *)"lv" },
50	{ "x-devanagari", 0x0905, (const FcChar8 *)"hi" },
51	{ "x-tamil", 0x0B85, (const FcChar8 *)"ta" },
52	{ "x-unicode", 0x0000, 0 },
53	{ "x-user-def", 0x0000, 0 },
54	};
55
56	#define NUM_XFT_LANG_GROUPS (sizeof (MozXftLangGroups) / \
57	sizeof (MozXftLangGroups[0]))
58
59	static
60	void FFREToFamily(nsACString &aFFREName, nsACString &oFamily);
61
62	static
63	const MozXftLangGroup*
64	FindFCLangGroup (nsACString &aLangGroup)
65	{
66	for (unsigned int i=0; i < NUM_XFT_LANG_GROUPS; ++i) {
67	if (aLangGroup.Equals(MozXftLangGroups[i].mozLangGroup,
68	nsCaseInsensitiveCStringComparator())) {
69	return &MozXftLangGroups[i];
70	}
71	}
72
73	return nsnull;
74	}
75
76	int
77	NS_CalculateSlant(PRUint8 aStyle)
78	{
79	int fcSlant;
80
81	switch(aStyle) {
82	case NS_FONT_STYLE_ITALIC:
83	fcSlant = FC_SLANT_ITALIC;
84	break;
85	case NS_FONT_STYLE_OBLIQUE:
86	fcSlant = FC_SLANT_OBLIQUE;
87	break;
88	default:
89	fcSlant = FC_SLANT_ROMAN;
90	break;
91	}
92
93	return fcSlant;
94	}
95
96	int
97	NS_CalculateWeight (PRUint16 aWeight)
98	{
99	/*
100	* weights come in two parts crammed into one
101	* integer -- the "base" weight is weight / 100,
102	* the rest of the value is the "offset" from that
103	* weight -- the number of steps to move to adjust
104	* the weight in the list of supported font weights,
105	* this value can be negative or positive.
106	*/
107	PRInt32 baseWeight = (aWeight + 50) / 100;
108	PRInt32 offset = aWeight - baseWeight * 100;
109
110	/* clip weights to range 0 to 9 */
111	if (baseWeight < 0)
112	baseWeight = 0;
113	if (baseWeight > 9)
114	baseWeight = 9;
115
116	/* Map from weight value to fcWeights index */
117	static int fcWeightLookup[10] = {
118	0, 0, 0, 0, 1, 1, 2, 3, 3, 4,
119	};
120
121	PRInt32 fcWeight = fcWeightLookup[baseWeight];
122
123	/*
124	* adjust by the offset value, make sure we stay inside the
125	* fcWeights table
126	*/
127	fcWeight += offset;
128	if (fcWeight < 0)
129	fcWeight = 0;
130	if (fcWeight > 4)
131	fcWeight = 4;
132
133	/* Map to final FC_WEIGHT value */
134	static int fcWeights[5] = {
135	FC_WEIGHT_LIGHT, /* 0 */
136	FC_WEIGHT_MEDIUM, /* 1 */
137	FC_WEIGHT_DEMIBOLD, /* 2 */
138	FC_WEIGHT_BOLD, /* 3 */
139	FC_WEIGHT_BLACK, /* 4 */
140	};
141
142	return fcWeights[fcWeight];
143	}
144
145	void
146	NS_AddLangGroup(FcPattern aPattern, nsIAtom aLangGroup)
147	{
148	// Find the FC lang group for this lang group
149	nsCAutoString cname;
150	aLangGroup->ToUTF8String(cname);
151
152	// see if the lang group needs to be translated from mozilla's
153	// internal mapping into fontconfig's
154	const struct MozXftLangGroup *langGroup;
155	langGroup = FindFCLangGroup(cname);
156
157	// if there's no lang group, just use the lang group as it was
158	// passed to us
159	//
160	// we're casting away the const here for the strings - should be
161	// safe.
162	if (!langGroup)
163	FcPatternAddString(aPattern, FC_LANG, (FcChar8 *)cname.get());
164	else if (langGroup->XftLang)
165	FcPatternAddString(aPattern, FC_LANG, (FcChar8 *)langGroup->XftLang);
166	}
167
168	void
169	NS_AddFFRE(FcPattern aPattern, nsCString aFamily, PRBool aWeak)
170	{
171	nsCAutoString family;
172	FFREToFamily(*aFamily, family);
173
174	FcValue v;
175	v.type = FcTypeString;
176	// casting away the const here, should be safe
177	v.u.s = (FcChar8 *)family.get();
178
179	if (aWeak)
180	FcPatternAddWeak(aPattern, FC_FAMILY, v, FcTrue);
181	else
182	FcPatternAdd(aPattern, FC_FAMILY, v, FcTrue);
183	}
184
185	/* static */
186	void
187	FFREToFamily(nsACString &aFFREName, nsACString &oFamily)
188	{
189	if (NS_FFRECountHyphens(aFFREName) == 3) {
190	PRInt32 familyHyphen = aFFREName.FindChar('-') + 1;
191	PRInt32 registryHyphen = aFFREName.FindChar('-',familyHyphen);
192	oFamily.Append(Substring(aFFREName, familyHyphen,
193	registryHyphen-familyHyphen));
194	}
195	else {
196	oFamily.Append(aFFREName);
197	}
198	}
199
200	int
201	NS_FFRECountHyphens (nsACString &aFFREName)
202	{
203	int h = 0;
204	PRInt32 hyphen = 0;
205	while ((hyphen = aFFREName.FindChar('-', hyphen)) >= 0) {
206	++h;
207	++hyphen;
208	}
209	return h;
210	}
211
212	PRBool
213	NS_IsASCIIFontName(const nsString& aName)
214	{
215	PRUint32 len = aName.Length();
216	const PRUnichar* str = aName.get();
217	for (PRUint32 i = 0; i < len; i++) {
218	/*
219	* X font names are printable ASCII, ignore others (for now)
220	*/
221	if ((str[i] < 0x20) \|\| (str[i] > 0x7E)) {
222	return PR_FALSE;
223	}
224	}
225
226	return PR_TRUE;
227	}

Added Link Here

(-)gfx/src/shared/nsFontConfigUtils.h (+55 lines)
1	/* -- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -- */
2	/* *** BEGIN LICENSE BLOCK ***
3	* Version: MPL 1.1/GPL 2.0/LGPL 2.1
4	*
5	* The contents of this file are subject to the Mozilla Public License Version
6	* 1.1 (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at
8	* http://www.mozilla.org/MPL/
9	*
10	* Software distributed under the License is distributed on an "AS IS" basis,
11	* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12	* for the specific language governing rights and limitations under the
13	* License.
14	*
15	* The Original Code is mozilla.org code.
16	*
17	* The Initial Developer of the Original Code is Christopher Blizzard
18	* <blizzard@mozilla.org>. Portions created by the Initial Developer
19	* are Copyright (C) 2002 the Initial Developer. All Rights Reserved.
20	*
21	* Contributor(s):
22	*
23	* Alternatively, the contents of this file may be used under the terms of
24	* either of the GNU General Public License Version 2 or later (the "GPL"),
25	* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
26	* in which case the provisions of the GPL or the LGPL are applicable instead
27	* of those above. If you wish to allow use of your version of this file only
28	* under the terms of either the GPL or the LGPL, and not to allow others to
29	* use your version of this file under the terms of the MPL, indicate your
30	* decision by deleting the provisions above and replace them with the notice
31	* and other provisions required by the GPL or the LGPL. If you do not delete
32	* the provisions above, a recipient may use your version of this file under
33	* the terms of any one of the MPL, the GPL or the LGPL.
34	*
35	* *** END LICENSE BLOCK *** */
36
37	#ifndef nsFontConfigUtils_h__
38	#define nsFontConfigUtils_h__
39
40	#include "nspr.h"
41	#include "nsString.h"
42	#include "nsIAtom.h"
43	#include "nsFont.h"
44
45	#include <fontconfig/fontconfig.h>
46
47	extern int NS_CalculateSlant (PRUint8 aStyle);
48	extern int NS_CalculateWeight (PRUint16 aWeight);
49	extern void NS_AddLangGroup (FcPattern aPattern, nsIAtom aLangGroup);
50	extern void NS_AddFFRE (FcPattern aPattern, nsCString aFamily,
51	PRBool aWeak);
52	extern int NS_FFRECountHyphens (nsACString &aFFREName);
53	extern PRBool NS_IsASCIIFontName (const nsString& aName);
54	#endif
55