MOZ_ENABLE_PANGO        = @MOZ_ENABLE_PANGO@

MOZ_PANGO_CFLAGS        = @MOZ_PANGO_CFLAGS@

MOZ_PANGO_LIBS          = @MOZ_PANGO_LIBS@

#ifdef MOZ_ENABLE_PANGO

#include "nsFontMetricsPango.h"

#endif

#ifdef MOZ_ENABLE_PANGO

  if (NS_IsPangoEnabled()) {

    result = new nsFontMetricsPango();

    if (!result)

      return NS_ERROR_OUT_OF_MEMORY;

  } else {

#endif

#ifdef MOZ_ENABLE_PANGO

  }

#endif

#ifdef MOZ_ENABLE_PANGO

  if (NS_IsPangoEnabled()) {

    result = new nsFontEnumeratorPango();

    if (!result)

      return NS_ERROR_OUT_OF_MEMORY;

  } else {

#endif

#ifdef MOZ_ENABLE_PANGO

  }

#endif

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/* vim:expandtab:shiftwidth=4:tabstop=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) 2004 the Initial Developer. All Rights Reserved.

 *

 * Contributor(s):

 *

 * 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

 * 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 _MOZILLA_DECODER_H

#define _MOZILLA_DECODER_H

#include <pango/pangofc-decoder.h>

G_BEGIN_DECLS

#define MOZILLA_TYPE_DECODER (mozilla_decoder_get_type())

#define MOZILLA_DECODER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), MOZILLA_TYPE_DECODER, MozillaDecoder))

#define MOZILLA_IS_DECODER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), MOZILLA_TYPE_DECODER))

typedef struct _MozillaDecoder      MozillaDecoder;

typedef struct _MozillaDecoderClass MozillaDecoderClass;

#define MOZILLA_DECODER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MOZILLA_TYPE_DECODER, MozillaDecoderClass))

#define MOZILLA_IS_DECODER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOZILLA_TYPE_DECODER))

#define MOZILLA_DECODER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOZILLA_TYPE_DECODER, MozillaDecoderClass))

struct _MozillaDecoder

{

  PangoFcDecoder parent_instance;

};

struct _MozillaDecoderClass

{

  PangoFcDecoderClass parent_class;

};

GType           mozilla_decoder_get_type (void);

int             mozilla_decoders_init    (void);

G_END_DECLS

#endif /*_MOZILLA_DECODER_H */

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/* vim:expandtab:shiftwidth=4:tabstop=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) 2004 the Initial Developer. All Rights Reserved.

 *

 * Contributor(s):

 *

 * 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

 * 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 ***** */

#define PANGO_ENABLE_BACKEND

#define PANGO_ENABLE_ENGINE

#include "mozilla-decoder.h"

#include <pango/pangoxft.h>

#include <pango/pangofc-fontmap.h>

#include <pango/pangofc-font.h>

#include <gdk/gdkx.h>

#include "nsString.h"

#include "nsIPersistentProperties2.h"

#include "nsNetUtil.h"

#include "nsReadableUtils.h"

#include "nsICharsetConverterManager.h"

#include "nsICharRepresentable.h"

#include "nsCompressedCharMap.h"

#undef DEBUG_CUSTOM_ENCODER

G_DEFINE_TYPE (MozillaDecoder, mozilla_decoder, PANGO_TYPE_FC_DECODER)

MozillaDecoder *mozilla_decoder_new      (void);

static FcCharSet  *mozilla_decoder_get_charset (PangoFcDecoder *decoder,

                                                PangoFcFont    *fcfont);

static PangoGlyph  mozilla_decoder_get_glyph   (PangoFcDecoder *decoder,

                                                PangoFcFont    *fcfont,

                                                guint32         wc);

static PangoFcDecoder *mozilla_find_decoder    (FcPattern *pattern,

                                                gpointer   user_data);

typedef struct _MozillaDecoderPrivate MozillaDecoderPrivate;

#define MOZILLA_DECODER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), MOZILLA_TYPE_DECODER, MozillaDecoderPrivate))

struct _MozillaDecoderPrivate {

    char *family;

    char *encoder;

    char *cmap;

    gboolean is_wide;

    FcCharSet *charset;

    nsCOMPtr<nsIUnicodeEncoder> uEncoder;

};

static nsICharsetConverterManager *gCharsetManager = NULL;

static NS_DEFINE_CID(kCharsetConverterManagerCID,

                     NS_ICHARSETCONVERTERMANAGER_CID);

// Hash tables that hold the custom encodings and custom cmaps used in

// various fonts.

GHashTable *encoder_hash = NULL;

GHashTable *cmap_hash = NULL;

GHashTable *wide_hash = NULL;

void

mozilla_decoder_init (MozillaDecoder *decoder)

{

}

void

mozilla_decoder_class_init (MozillaDecoderClass *klass)

{

    GObjectClass *object_class = G_OBJECT_CLASS(klass);

    PangoFcDecoderClass *parent_class = PANGO_FC_DECODER_CLASS (klass);

    /*   object_class->finalize = test_finalize; */

    parent_class->get_charset = mozilla_decoder_get_charset;

    parent_class->get_glyph = mozilla_decoder_get_glyph;

    g_type_class_add_private (object_class, sizeof (MozillaDecoderPrivate));

}

MozillaDecoder *

mozilla_decoder_new(void)

{

    return (MozillaDecoder *)g_object_new(MOZILLA_TYPE_DECODER, NULL);

}

#ifdef DEBUG_CUSTOM_ENCODER

void

dump_hash(char *key, char *val, void *arg)

{

    printf("%s -> %s\n", key, val);

}

#endif

/**

 * mozilla_decoders_init:

 *

 * #mozilla_decoders_init:

 *

 * This initializes all of the application-specific custom decoders

 * that Mozilla uses.  This should only be called once during the

 * lifetime of the application.

 *

 * Return value: zero on success, not zero on failure.

 *

 **/

int

mozilla_decoders_init(void)

{

    static PRBool initialized = PR_FALSE;

    if (initialized)

        return 0;

    encoder_hash = g_hash_table_new(g_str_hash, g_str_equal);

    cmap_hash = g_hash_table_new(g_str_hash, g_str_equal);

    wide_hash = g_hash_table_new(g_str_hash, g_str_equal);

    PRBool dumb = PR_FALSE;

    nsCOMPtr<nsIPersistentProperties> props;

    nsCOMPtr<nsISimpleEnumerator> encodeEnum;

    NS_LoadPersistentPropertiesFromURISpec(getter_AddRefs(props),

        NS_LITERAL_CSTRING("resource://gre/res/fonts/pangoFontEncoding.properties"));

    if (!props)

        goto loser;

    // Enumerate the properties in this file and figure out all of the

    // fonts for which we have custom encodings.

    props->Enumerate(getter_AddRefs(encodeEnum));

    if (!encodeEnum)

        goto loser;

    while (encodeEnum->HasMoreElements(&dumb), dumb) {

        nsCOMPtr<nsIPropertyElement> prop;

        encodeEnum->GetNext(getter_AddRefs(prop));

        if (!prop)

            goto loser;

        nsCAutoString name;

        prop->GetKey(name);

        nsAutoString value;

        prop->GetValue(value);

        if (!StringBeginsWith(name, NS_LITERAL_CSTRING("encoding."))) {

            printf("string doesn't begin with encoding?\n");

            continue;

        }

        name = Substring(name, 9);

        if (StringEndsWith(name, NS_LITERAL_CSTRING(".ttf"))) {

            name = Substring(name, 0, name.Length() - 4);

            // Strip off a .wide if it's there.

            if (StringEndsWith(value, NS_LITERAL_STRING(".wide"))) {

                g_hash_table_insert(wide_hash, g_strdup(name.get()),

                                    g_strdup("wide"));

                value = Substring(value, 0, name.Length() - 5);

            }

            g_hash_table_insert(encoder_hash,

                                g_strdup(name.get()),

                                g_strdup(NS_ConvertUTF16toUTF8(value).get()));

        }

        else if (StringEndsWith(name, NS_LITERAL_CSTRING(".ftcmap"))) {

            name = Substring(name, 0, name.Length() - 7);

            g_hash_table_insert(cmap_hash,

                                g_strdup(name.get()),

                                g_strdup(NS_ConvertUTF16toUTF8(value).get()));

        }

        else {

            printf("unknown suffix used for mapping\n");

        }

    }

    pango_fc_font_map_add_decoder_find_func(PANGO_FC_FONT_MAP(pango_xft_get_font_map(GDK_DISPLAY(),gdk_x11_get_default_screen())),

                                            mozilla_find_decoder,

                                            NULL,

                                            NULL);

    initialized = PR_TRUE;

#ifdef DEBUG_CUSTOM_ENCODER

    printf("*** encoders\n");

    g_hash_table_foreach(encoder_hash, (GHFunc)dump_hash, NULL);

    printf("*** cmaps\n");

    g_hash_table_foreach(cmap_hash, (GHFunc)dump_hash, NULL);

#endif

    return 0;

 loser:

    return -1;

}

FcCharSet *

mozilla_decoder_get_charset (PangoFcDecoder *decoder,

                             PangoFcFont    *fcfont)

{

    MozillaDecoderPrivate *priv = MOZILLA_DECODER_GET_PRIVATE(decoder);

    if (priv->charset)

        return priv->charset;

    // First time this has been accessed.  Populate the charset.

    priv->charset = FcCharSetCreate();

    if (!gCharsetManager) {

        nsServiceManager::GetService(kCharsetConverterManagerCID,

        NS_GET_IID(nsICharsetConverterManager), (nsISupports**)&gCharsetManager);

    }

    nsCOMPtr<nsIUnicodeEncoder> encoder;

    nsCOMPtr<nsICharRepresentable> represent;

    if (!gCharsetManager)

        goto end;

    gCharsetManager->GetUnicodeEncoderRaw(priv->encoder, getter_AddRefs(encoder));

    if (!encoder)

        goto end;

    encoder->SetOutputErrorBehavior(encoder->kOnError_Replace, nsnull, '?');

    priv->uEncoder = encoder;

    represent = do_QueryInterface(encoder);

    if (!represent)

        goto end;

    PRUint32 map[UCS2_MAP_LEN];

    memset(map, 0, sizeof(map));

    represent->FillInfo(map);

    for (int i = 0; i < NUM_UNICODE_CHARS; i++) {

        if (IS_REPRESENTABLE(map, i))

            FcCharSetAddChar(priv->charset, i);

    }

 end:

    return priv->charset;

}

PangoGlyph

mozilla_decoder_get_glyph   (PangoFcDecoder *decoder,

                             PangoFcFont    *fcfont,

                             guint32         wc)

{

    MozillaDecoderPrivate *priv = MOZILLA_DECODER_GET_PRIVATE(decoder);

    PangoGlyph retval = 0;

    PRUnichar inchar = wc;

    PRInt32 inlen = 1;

    char outchar[2] = {0,0};

    PRInt32 outlen = 2;

    priv->uEncoder->Convert(&inchar, &inlen, outchar, &outlen);

    if (outlen != 1) {

        printf("Warning: mozilla_decoder_get_glyph doesn't support more than one character conversions.\n");

        return 0;

    }

    FT_Face face = pango_fc_font_lock_face(fcfont);

#ifdef DEBUG_CUSTOM_ENCODER

    char *filename;

    FcPatternGetString(fcfont->font_pattern, FC_FILE, 0, (FcChar8 **)&filename);

    printf("filename is %s\n", filename);

#endif

    // Make sure to set the right charmap before trying to get the

    // glyph

    if (priv->cmap) {

        if (!strcmp(priv->cmap, "mac_roman")) {

            FT_Select_Charmap(face, ft_encoding_apple_roman);

        }

        else if (!strcmp(priv->cmap, "unicode")) {

            FT_Select_Charmap(face, ft_encoding_unicode);

        }

        else {

            printf("Warning: Invalid charmap entry for family %s\n",

                   priv->family);

        }

    }

    // Standard 8 bit to glyph translation

    if (!priv->is_wide) {

        FcChar32 blah = PRUint8(outchar[0]);

        retval = FT_Get_Char_Index(face, blah);

#ifdef DEBUG_CUSTOM_ENCODER

        printf("wc 0x%x outchar[0] 0x%x index 0x%x retval 0x%x face %p\n",

               wc, outchar[0], blah, retval, (void *)face);

#endif

    }

    else {

        printf("Warning: We don't support .wide fonts!\n");

        retval = 0;

    }

    pango_fc_font_unlock_face(fcfont);

    return retval;

}

PangoFcDecoder *

mozilla_find_decoder (FcPattern *pattern, gpointer user_data)

{

    // Compare the family name of the font that's been opened to see

    // if we have a custom decoder.

    const char *orig = NULL;

    FcPatternGetString(pattern, FC_FAMILY, 0, (FcChar8 **)&orig);

    nsCAutoString family;

    family.Assign(orig);

    family.StripWhitespace();

    ToLowerCase(family);

    char *encoder = (char *)g_hash_table_lookup(encoder_hash, family.get());

    if (!encoder)

        return NULL;

    MozillaDecoder *decoder = mozilla_decoder_new();

    MozillaDecoderPrivate *priv = MOZILLA_DECODER_GET_PRIVATE(decoder);

    priv->family = g_strdup(family.get());

    priv->encoder = g_strdup(encoder);

    char *cmap = (char *)g_hash_table_lookup(cmap_hash, family.get());

    if (cmap)

        priv->cmap = g_strdup(cmap);

    char *wide = (char *)g_hash_table_lookup(wide_hash, family.get());

    if (wide)

        priv->is_wide = TRUE;

    return PANGO_FC_DECODER(decoder);

}

#if MOZ_ENABLE_PANGO

dist/bin/res/fonts/pangoFontEncoding.properties

#endif

#ifdef DEBUG_foo

    printf("%i\n", mXHeight);

    printf("%i\n", mSuperscriptOffset);

    printf("%i\n", mSubscriptOffset);

    printf("%i\n", mStrikeoutOffset);

    printf("%i\n", mStrikeoutSize);

    printf("%i\n", mUnderlineOffset);

    printf("%i\n", mUnderlineSize);

    printf("%i\n", mMaxHeight);

    printf("%i\n", mLeading);

    printf("%i\n", mEmHeight);

    printf("%i\n", mEmAscent);

    printf("%i\n", mEmDescent);

    printf("%i\n", mMaxAscent);

    printf("%i\n", mMaxDescent);

    printf("%i\n", mMaxAdvance);

    printf("%i\n", mSpaceWidth);

    printf("%i\n", mAveCharWidth);

#endif /* DEBUG_foo */

#ifdef DEBUG_foo

    printf("GetWidth (char *) %d\n", aWidth);

#endif

#ifdef DEBUG_foo

    printf("GetWidth %d\n", aWidth);

#endif

#ifdef DEBUG_foo

    printf("GetTextDimensions %d %d %d\n", aDimensions.width,

           aDimensions.ascent, aDimensions.descent);

#endif

#ifdef DEBUG_foo

    printf("DrawString (char *)\n");

#endif

#ifdef DEBUG_foo

    printf("DrawString\n");

#endif

#ifdef DEBUG_foo

    printf("GetBoundingMetrics (char *)%d %d %d %d %d\n",

           aBoundingMetrics.leftBearing,

           aBoundingMetrics.rightBearing,

           aBoundingMetrics.width,

           aBoundingMetrics.ascent,

           aBoundingMetrics.descent);

#endif

#ifdef DEBUG_foo

    printf("GetBoundingMetrics %d %d %d %d %d\n",

           aBoundingMetrics.leftBearing,

           aBoundingMetrics.rightBearing,

           aBoundingMetrics.width,

           aBoundingMetrics.ascent,

           aBoundingMetrics.descent);

#endif

nsresult

nsFontMetricsXft::SetRightToLeftText(PRBool aIsRTL)

{

    return NS_OK;

}

ifdef MOZ_ENABLE_PANGO

CPPSRCS		+= \

		nsFontMetricsPango.cpp \

		mozilla-decoder.cpp

endif

# ***** 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 MathML Project.

#

# The Initial Developer of the Original Code is

# The University of Queensland.

# Portions created by the Initial Developer are Copyright (C) 2001

# the Initial Developer. All Rights Reserved.

#

# Contributor(s):

#   Roger B. Sidje <rbs@maths.uq.edu.au>

#   Jungshik Shin <jshin@mailaps.org>

#   Christopher Blizzard <blizzard@mozilla.org>

#

# 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

# 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 *****

#  LOCALIZATION NOTE: FILE

#  Do not translate anything in this file

# This file contains supported custom encodings for pango font

# rendering.  For information about the specific encodings, look at

# fontEncoding.properties.  It contains a lot more verbiage than you

# will find here.  There are a lot of encodings supported in the old

# encoding file that pango supports directly, so there should be

# little reason to use those custom encodings.  The pango custom code

# doesn't support .wide fonts, so consider yourself warned!

#

# To be honest, we basically support mathml and that's about it.

encoding.cmr10.ttf  = x-ttf-cmr

encoding.cmmi10.ttf = x-ttf-cmmi

encoding.cmsy10.ttf = x-ttf-cmsy

encoding.cmex10.ttf = x-ttf-cmex

encoding.cmr10.ftcmap  = unicode

encoding.cmmi10.ftcmap = unicode

encoding.cmsy10.ftcmap = unicode

encoding.cmex10.ftcmap = unicode

encoding.math1.ttf          = x-mathematica1

encoding.math1-bold.ttf     = x-mathematica1

encoding.math1mono.ttf      = x-mathematica1

encoding.math1mono-bold.ttf = x-mathematica1

encoding.math2.ttf          = x-mathematica2

encoding.math2-bold.ttf     = x-mathematica2

encoding.math2mono.ttf      = x-mathematica2

encoding.math2mono-bold.ttf = x-mathematica2

encoding.math3.ttf          = x-mathematica3

encoding.math3-bold.ttf     = x-mathematica3

encoding.math3mono.ttf      = x-mathematica3

encoding.math3mono-bold.ttf = x-mathematica3

encoding.math4.ttf          = x-mathematica4

encoding.math4-bold.ttf     = x-mathematica4

encoding.math4mono.ttf      = x-mathematica4

encoding.math4mono-bold.ttf = x-mathematica4

encoding.math5.ttf          = x-mathematica5

encoding.math5-bold.ttf     = x-mathematica5

encoding.math5bold.ttf      = x-mathematica5

encoding.math5mono.ttf      = x-mathematica5

encoding.math5mono-bold.ttf = x-mathematica5

encoding.math5monobold.ttf  = x-mathematica5

encoding.math1.ftcmap          = mac_roman

encoding.math1-bold.ftcmap     = mac_roman

encoding.math1mono.ftcmap      = mac_roman

encoding.math1mono-bold.ftcmap = mac_roman

encoding.math2.ftcmap          = mac_roman

encoding.math2-bold.ftcmap     = mac_roman

encoding.math2mono.ftcmap      = mac_roman

encoding.math2mono-bold.ftcmap = mac_roman

encoding.math3.ftcmap          = mac_roman

encoding.math3-bold.ftcmap     = mac_roman

encoding.math3mono.ftcmap      = mac_roman

encoding.math3mono-bold.ftcmap = mac_roman

encoding.math4.ftcmap          = mac_roman

encoding.math4-bold.ftcmap     = mac_roman

encoding.math4mono.ftcmap      = mac_roman

encoding.math4mono-bold.ftcmap = mac_roman

encoding.math5.ftcmap          = mac_roman

encoding.math5-bold.ftcmap     = mac_roman

encoding.math5bold.ftcmap      = mac_roman

encoding.math5mono.ftcmap      = mac_roman

encoding.math5mono-bold.ftcmap = mac_roman

encoding.math5monobold.ftcmap  = mac_roman

encoding.mtextra.ttf = x-mtextra

encoding.mtextra.ftcmap = mac_roman

#ifdef MOZ_ENABLE_PANGO

#include "nsFontMetricsPango.h"

#endif

#ifdef MOZ_ENABLE_PANGO

    if (NS_IsPangoEnabled()) {

        return nsFontMetricsPango::GetHints();

    }

#endif

#ifdef MOZ_ENABLE_PANGO

    if (NS_IsPangoEnabled()) {

        return nsFontMetricsPango::FamilyExists(aDevice, aName);

    }

#endif

#ifdef MOZ_ENABLE_PANGO

PRBool

NS_IsPangoEnabled(void)

{

    char *val = PR_GetEnv("MOZ_ENABLE_PANGO");

    if (val)

        return TRUE;

    return FALSE;

}

#endif

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/* vim:expandtab:shiftwidth=4:tabstop=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) 2004 the Initial Developer. All Rights Reserved.

 *

 * Contributor(s):

 *

 * 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

 * 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 "nsFont.h"

#include "nsIDeviceContext.h"

#include "nsICharsetConverterManager.h"

#include "nsIPref.h"

#include "nsIServiceManagerUtils.h"

#define PANGO_ENABLE_BACKEND

#define PANGO_ENABLE_ENGINE

#include "nsFontMetricsPango.h"

#include "nsRenderingContextGTK.h"

#include "nsDeviceContextGTK.h"

#include "nsUnicharUtils.h"

#include "nsQuickSort.h"

#include <pango/pangoxft.h>

#include <fontconfig/fontconfig.h>

#include <gdk/gdk.h>

#include <gdk/gdkx.h>

#include <freetype/tttables.h>

#include "mozilla-decoder.h"

#define FORCE_PR_LOG

#include "prlog.h"

// Globals

static PRLogModuleInfo            *gPangoFontLog;

static int                         gNumInstances;

// Defines

// This is the scaling factor that we keep fonts limited to against

// the display size.  If a pixel size is requested that is more than

// 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

static NS_DEFINE_CID(kCharsetConverterManagerCID,

                     NS_ICHARSETCONVERTERMANAGER_CID);

struct MozPangoLangGroup {

    const char *mozLangGroup;

    const char *PangoLang;

};

static const MozPangoLangGroup MozPangoLangGroups[] = {

    { "x-western",      "en" },

    { "x-central-euro", "pl" },

    { "x-cyrillic",     "ru" },

    { "x-baltic",       "lv" },

    { "x-devanagari",   "hi" },

    { "x-tamil",        "ta" },

    { "x-unicode",      0    },

    { "x-user-def",     0    },

};

#define NUM_PANGO_LANG_GROUPS (sizeof (MozPangoLangGroups) / \

                               sizeof (MozPangoLangGroups[0]))

#ifdef DEBUG

#define DUMP_PRUNICHAR(ustr, ulen) for (PRUint32 llen=0;llen<ulen;llen++) \

                                      printf("0x%x ", ustr[llen]); \

                                   printf("\n");

#endif

// rounding and truncation functions for a Freetype floating point number 

// (FT26Dot6) stored in a 32bit integer with high 26 bits for the integer

// part and low 6 bits for the fractional part. 

#define MOZ_FT_ROUND(x) (((x) + 32) & ~63) // 63 = 2^6 - 1

#define MOZ_FT_TRUNC(x) ((x) >> 6)

#define CONVERT_DESIGN_UNITS_TO_PIXELS(v, s) \

        MOZ_FT_TRUNC(MOZ_FT_ROUND(FT_MulFix((v) , (s))))

// Static function decls

static PRBool IsASCIIFontName  (const nsString& aName);

static int    FFRECountHyphens (nsACString &aFFREName);

static PangoLanguage *GetPangoLanguage(nsIAtom *aLangGroup);

static const MozPangoLangGroup* FindPangoLangGroup (nsACString &aLangGroup);

static void   FreeGlobals    (void);

static PangoStyle  CalculateStyle  (PRUint8 aStyle);

static PangoWeight CalculateWeight (PRUint16 aWeight);

static nsresult    EnumFontsPango   (nsIAtom* aLangGroup, const char* aGeneric,

                                     PRUint32* aCount, PRUnichar*** aResult);

static int         CompareFontNames (const void* aArg1, const void* aArg2,

                                     void* aClosure);

extern void     AddLangGroup     (FcPattern *aPattern, nsIAtom *aLangGroup);

nsFontMetricsPango::nsFontMetricsPango()

{

    if (!gPangoFontLog)

        gPangoFontLog = PR_NewLogModule("PangoFont");

    gNumInstances++;

    mPangoFontDesc = nsnull;

    mPangoContext = nsnull;

    mLTRPangoContext = nsnull;

    mRTLPangoContext = nsnull;

    mPangoAttrList = nsnull;

    mIsRTL = PR_FALSE;

    static PRBool initialized = PR_FALSE;

    if (initialized)

        return;

    // Initialized the custom decoders

    if (!mozilla_decoders_init())

        initialized = PR_TRUE;

}

nsFontMetricsPango::~nsFontMetricsPango()

{

    delete mFont;

    if (mDeviceContext)

        mDeviceContext->FontMetricsDeleted(this);

    if (mPangoFontDesc)

        pango_font_description_free(mPangoFontDesc);

    if (mLTRPangoContext)

        g_object_unref(mLTRPangoContext);

    if (mRTLPangoContext)

        g_object_unref(mRTLPangoContext);

    if (mPangoAttrList)

        pango_attr_list_unref(mPangoAttrList);

    // XXX clean up all the pango objects

    if (--gNumInstances == 0)

        FreeGlobals();

}

NS_IMPL_ISUPPORTS1(nsFontMetricsPango, nsIFontMetrics)

// nsIFontMetrics impl

NS_IMETHODIMP

nsFontMetricsPango::Init(const nsFont& aFont, nsIAtom* aLangGroup,

                         nsIDeviceContext *aContext)

{

    mFont = new nsFont(aFont);

    mLangGroup = aLangGroup;

    // Hang on to the device context

    mDeviceContext = aContext;

    mPointSize = NSTwipsToFloatPoints(mFont->size);

    // Make sure to clamp the pixel size to something reasonable so we

    // don't make the X server blow up.

    nscoord screenPixels = gdk_screen_height();

    mPointSize = PR_MIN(screenPixels * FONT_MAX_FONT_SCALE, mPointSize);

    // enumerate over the font names passed in

    mFont->EnumerateFamilies(nsFontMetricsPango::EnumFontCallback, this);

    nsCOMPtr<nsIPref> prefService;

    prefService = do_GetService(NS_PREF_CONTRACTID);

    if (!prefService)

        return NS_ERROR_FAILURE;

    nsXPIDLCString value;

    // Set up the default font name if it's not set

    if (!mGenericFont) {

        prefService->CopyCharPref("font.default", getter_Copies(value));

        if (value.get())

            mDefaultFont = value.get();

        else

            mDefaultFont = "serif";

        mGenericFont = &mDefaultFont;

    }

    // set up the minimum sizes for fonts

    if (mLangGroup) {

        nsCAutoString name("font.min-size.");

        if (mGenericFont->Equals("monospace"))

            name.Append("fixed");

        else

            name.Append("variable");

        name.Append(char('.'));

        const char* langGroup;

        mLangGroup->GetUTF8String(&langGroup);

        name.Append(langGroup);

        PRInt32 minimumInt = 0;

        float minimum;

        nsresult res;

        res = prefService->GetIntPref(name.get(), &minimumInt);

        if (NS_FAILED(res))

            prefService->GetDefaultIntPref(name.get(), &minimumInt);

        if (minimumInt < 0)

            minimumInt = 0;

        minimum = minimumInt;

        // The minimum size is specified in pixels, not in points.

        // Convert the size from pixels to points.

        minimum = NSTwipsToFloatPoints(NSFloatPixelsToTwips(minimum, mDeviceContext->DevUnitsToAppUnits()));

        if (mPointSize < minimum)

            mPointSize = minimum;

    }

    // Make sure that the pixel size is at least greater than zero

    if (mPointSize < 1) {

#ifdef DEBUG

        printf("*** Warning: nsFontMetricsPango created with point size %f\n",

               mPointSize);

#endif

        mPointSize = 1;

    }

    nsresult rv = RealizeFont();

    if (NS_FAILED(rv))

        return rv;

    // Cache font metrics for the 'x' character

    return CacheFontMetrics();

}

nsresult

nsFontMetricsPango::CacheFontMetrics(void)

{

    // Get our scale factor

    float f;

    float val;

    f = mDeviceContext->DevUnitsToAppUnits();

    mPangoAttrList = pango_attr_list_new();

    GList *items = pango_itemize(mPangoContext,

                                 "a", 0, 1, mPangoAttrList, NULL);

    if (!items)

        return NS_ERROR_FAILURE;

    guint nitems = g_list_length(items);

    if (nitems != 1)

        return NS_ERROR_FAILURE;

    PangoItem *item = (PangoItem *)items->data;

    PangoFcFont  *fcfont = PANGO_FC_FONT(item->analysis.font);

    if (!fcfont)

        return NS_ERROR_FAILURE;

    // Get our font face

    FT_Face face;

    TT_OS2 *os2;

    XftFont *xftFont = pango_xft_font_get_font(PANGO_FONT(fcfont));

    if (!xftFont)

        return NS_ERROR_NOT_AVAILABLE;

    face = XftLockFace(xftFont);

    os2 = (TT_OS2 *) FT_Get_Sfnt_Table(face, ft_sfnt_os2);

    // mEmHeight (size in pixels of EM height)

    int size;

    if (FcPatternGetInteger(fcfont->font_pattern, FC_PIXEL_SIZE, 0, &size) !=

        FcResultMatch) {

        size = 12;

    }

    mEmHeight = PR_MAX(1, nscoord(size * f));

    // mMaxAscent

    mMaxAscent = nscoord(xftFont->ascent * f);

    // mMaxDescent

    mMaxDescent = nscoord(xftFont->descent * f);

    nscoord lineHeight = mMaxAscent + mMaxDescent;

    // mLeading (needs ascent and descent and EM height) 

    if (lineHeight > mEmHeight)

        mLeading = lineHeight - mEmHeight;

    else

        mLeading = 0;

    // mMaxHeight (needs ascent and descent)

    mMaxHeight = lineHeight;

    // mEmAscent (needs maxascent, EM height, ascent and descent)

    mEmAscent = nscoord(mMaxAscent * mEmHeight / lineHeight);

    // mEmDescent (needs EM height and EM ascent

    mEmDescent = mEmHeight - mEmAscent;

    // mMaxAdvance

    mMaxAdvance = nscoord(xftFont->max_advance_width * f);

    // mSpaceWidth (width of a space)

    nscoord tmpWidth;

    GetWidth(" ", 1, tmpWidth, NULL);

    mSpaceWidth = tmpWidth;

    // mAveCharWidth (width of an 'average' char)

    //    XftTextExtents16(GDK_DISPLAY(), xftFont, &xUnichar, 1, &extents);

    //rawWidth = extents.width;

    //mAveCharWidth = NSToCoordRound(rawWidth * f);

    GetWidth("x", 1, tmpWidth, NULL);

    mAveCharWidth = tmpWidth;

    // mXHeight (height of an 'x' character)

    PRUnichar xUnichar('x');

    XGlyphInfo extents;

    if (FcCharSetHasChar(xftFont->charset, xUnichar)) {

        XftTextExtents16(GDK_DISPLAY(), xftFont, &xUnichar, 1, &extents);

        mXHeight = extents.height;

    }

    else {

        // 56% of ascent, best guess for non-true type or asian fonts

        mXHeight = nscoord(((float)mMaxAscent) * 0.56);

    }

    mXHeight = nscoord(mXHeight * f);

    // mUnderlineOffset (offset for underlines)

    val = CONVERT_DESIGN_UNITS_TO_PIXELS(face->underline_position,

                                         face->size->metrics.y_scale);

    if (val) {

        mUnderlineOffset = NSToIntRound(val * f);

    }

    else {

        mUnderlineOffset =

            -NSToIntRound(PR_MAX(1, floor(0.1 * xftFont->height + 0.5)) * f);

    }

    // mUnderlineSize (thickness of an underline)

    val = CONVERT_DESIGN_UNITS_TO_PIXELS(face->underline_thickness,

                                         face->size->metrics.y_scale);

    if (val) {

        mUnderlineSize = nscoord(PR_MAX(f, NSToIntRound(val * f)));

    }

    else {

        mUnderlineSize =

            NSToIntRound(PR_MAX(1, floor(0.05 * xftFont->height + 0.5)) * f);

    }

    // mSuperscriptOffset

    if (os2 && os2->ySuperscriptYOffset) {

        val = CONVERT_DESIGN_UNITS_TO_PIXELS(os2->ySuperscriptYOffset,

                                             face->size->metrics.y_scale);

        mSuperscriptOffset = nscoord(PR_MAX(f, NSToIntRound(val * f)));

    }

    else {

        mSuperscriptOffset = mXHeight;

    }

    // mSubscriptOffset

    if (os2 && os2->ySubscriptYOffset) {

        val = CONVERT_DESIGN_UNITS_TO_PIXELS(os2->ySubscriptYOffset,

                                             face->size->metrics.y_scale);

        // some fonts have the incorrect sign. 

        val = (val < 0) ? -val : val;

        mSubscriptOffset = nscoord(PR_MAX(f, NSToIntRound(val * f)));

    }

    else {

        mSubscriptOffset = mXHeight;

    }

    // mStrikeoutOffset

    mStrikeoutOffset = NSToCoordRound(mXHeight / 2.0);

    // mStrikeoutSize

    mStrikeoutSize = mUnderlineSize;

    XftUnlockFace(xftFont);

    /*

    printf("%i\n", mXHeight);

    printf("%i\n", mSuperscriptOffset);

    printf("%i\n", mSubscriptOffset);

    printf("%i\n", mStrikeoutOffset);

    printf("%i\n", mStrikeoutSize);

    printf("%i\n", mUnderlineOffset);

    printf("%i\n", mUnderlineSize);

    printf("%i\n", mMaxHeight);

    printf("%i\n", mLeading);

    printf("%i\n", mEmHeight);

    printf("%i\n", mEmAscent);

    printf("%i\n", mEmDescent);

    printf("%i\n", mMaxAscent);

    printf("%i\n", mMaxDescent);

    printf("%i\n", mMaxAdvance);

    printf("%i\n", mSpaceWidth);

    printf("%i\n", mAveCharWidth);

    */

    return NS_OK;

}

NS_IMETHODIMP

nsFontMetricsPango::Destroy()

{

    mDeviceContext = nsnull;

    return NS_OK;

}

NS_IMETHODIMP

nsFontMetricsPango::GetFont(const nsFont *&aFont)

{

    aFont = mFont;

    return NS_OK;

}

NS_IMETHODIMP

nsFontMetricsPango::GetLangGroup(nsIAtom** aLangGroup)

{

    *aLangGroup = mLangGroup;

    NS_IF_ADDREF(*aLangGroup);

    return NS_OK;

}

NS_IMETHODIMP

nsFontMetricsPango::GetFontHandle(nsFontHandle &aHandle)

{

    return NS_ERROR_NOT_IMPLEMENTED;

}

// nsIFontMetricsPango impl

nsresult

nsFontMetricsPango::GetWidth(const char* aString, PRUint32 aLength,

                             nscoord& aWidth,

                             nsRenderingContextGTK *aContext)

{

    PangoLayout *layout = pango_layout_new(mPangoContext);

    pango_layout_set_text(layout, aString, aLength);

    int width, height;

    pango_layout_get_size(layout, &width, &height);

    width /= PANGO_SCALE;

    g_object_unref(layout);

    float f;

    f = mDeviceContext->DevUnitsToAppUnits();

    aWidth = NSToCoordRound(width * f);

    //    printf("GetWidth (char *) %d\n", aWidth);

    return NS_OK;

}

nsresult

nsFontMetricsPango::GetWidth(const PRUnichar* aString, PRUint32 aLength,

                             nscoord& aWidth, PRInt32 *aFontID,

                             nsRenderingContextGTK *aContext)

{

    nsresult rv = NS_OK;

    PangoLayout *layout = pango_layout_new(mPangoContext);

    gchar *text = g_utf16_to_utf8(aString, aLength,

                                  NULL, NULL, NULL);

    if (!text) {

        aWidth = 0;

#ifdef DEBUG

        NS_WARNING("nsFontMetricsPango::GetWidth invalid unicode to follow");

        DUMP_PRUNICHAR(aString, aLength)

#endif

        rv = NS_ERROR_FAILURE;

        goto loser;

    }

    gint width, height;

    pango_layout_set_text(layout, text, strlen(text));

    pango_layout_get_size(layout, &width, &height);

    width /= PANGO_SCALE;

    float f;

    f = mDeviceContext->DevUnitsToAppUnits();

    aWidth = NSToCoordRound(width * f);

    //    printf("GetWidth %d\n", aWidth);

 loser:

    g_free(text);

    g_object_unref(layout);

    return rv;

}

nsresult

nsFontMetricsPango::GetTextDimensions(const PRUnichar* aString,

                                      PRUint32 aLength,

                                      nsTextDimensions& aDimensions, 

                                      PRInt32* aFontID,

                                      nsRenderingContextGTK *aContext)

{

    nsresult rv = NS_OK;

    PangoLayout *layout = pango_layout_new(mPangoContext);

    gchar *text = g_utf16_to_utf8(aString, aLength,

                                  NULL, NULL, NULL);

    if (!text) {

#ifdef DEBUG

        NS_WARNING("nsFontMetricsPango::GetTextDimensions invalid unicode to follow");

        DUMP_PRUNICHAR(aString, aLength)

#endif

        aDimensions.width = 0;

        aDimensions.ascent = 0;

        aDimensions.descent = 0;

        rv = NS_ERROR_FAILURE;

        goto loser;

    }

    pango_layout_set_text(layout, text, strlen(text));

    // Get the logical extents

    PangoLayoutLine *line;

    if (pango_layout_get_line_count(layout) != 1) {

        printf("Warning: more than one line!\n");

    }

    line = pango_layout_get_line(layout, 0);

    PangoRectangle rect;

    pango_layout_line_get_extents(line, NULL, &rect);

    float P2T;

    P2T = mDeviceContext->DevUnitsToAppUnits();

    aDimensions.width = NSToCoordRound(rect.width / PANGO_SCALE * P2T);

    aDimensions.ascent = NSToCoordRound(PANGO_ASCENT(rect) / PANGO_SCALE * P2T);

    aDimensions.descent = NSToCoordRound(PANGO_DESCENT(rect) / PANGO_SCALE * P2T);

    //    printf("GetTextDimensions %d %d %d\n", aDimensions.width,

    //aDimensions.ascent, aDimensions.descent);

 loser:

    g_free(text);

    g_object_unref(layout);

    return rv;

}

nsresult

nsFontMetricsPango::GetTextDimensions(const char*         aString,

                                      PRInt32             aLength,

                                      PRInt32             aAvailWidth,

                                      PRInt32*            aBreaks,

                                      PRInt32             aNumBreaks,

                                      nsTextDimensions&   aDimensions,

                                      PRInt32&            aNumCharsFit,

                                      nsTextDimensions&   aLastWordDimensions,

                                      PRInt32*            aFontID,

                                      nsRenderingContextGTK *aContext)

{

    return GetTextDimensionsInternal(aString, aLength, aAvailWidth, aBreaks,

                                     aNumBreaks, aDimensions, aNumCharsFit,

                                     aLastWordDimensions, aContext);

}

nsresult

nsFontMetricsPango::GetTextDimensions(const PRUnichar*    aString,

                                      PRInt32             aLength,

                                      PRInt32             aAvailWidth,

                                      PRInt32*            aBreaks,

                                      PRInt32             aNumBreaks,

                                      nsTextDimensions&   aDimensions,

                                      PRInt32&            aNumCharsFit,

                                      nsTextDimensions&   aLastWordDimensions,

                                      PRInt32*            aFontID,

                                      nsRenderingContextGTK *aContext)

{

    nsresult rv = NS_OK;

    PRInt32 curBreak = 0;

    gchar *curChar;

    PRInt32 *utf8Breaks = new PRInt32[aNumBreaks];

    gchar *text = g_utf16_to_utf8(aString, (PRInt32)aLength,

                                  NULL, NULL, NULL);

    curChar = text;

    if (!text) {

#ifdef DEBUG

        NS_WARNING("nsFontMetricsPango::GetWidth invalid unicode to follow");

        DUMP_PRUNICHAR(aString, (PRUint32)aLength)

#endif

        rv = NS_ERROR_FAILURE;

        goto loser;

    }

    // Covert the utf16 break offsets to utf8 break offsets

    for (PRInt32 curOffset=0; curOffset < aLength;

         curOffset++, curChar = g_utf8_find_next_char(curChar, NULL)) {

        if (aBreaks[curBreak] == curOffset) {

            utf8Breaks[curBreak] = curChar - text;

            curBreak++;

        }

        if (IS_HIGH_SURROGATE(aString[curOffset]))

            curOffset++;

    }

    // Always catch the last break

    utf8Breaks[curBreak] = curChar - text;

#if 0

    if (strlen(text) != aLength) {

        printf("Different lengths for utf16 %d and utf8 %d\n", aLength, strlen(text));

        DUMP_PRUNICHAR(aString, aLength)

        DUMP_PRUNICHAR(text, strlen(text))

        for (PRInt32 i = 0; i < aNumBreaks; ++i) {

            printf("  break %d utf16 %d utf8 %d\n", i, aBreaks[i], utf8Breaks[i]);

        }

    }

#endif

    // We'll use curBreak to indicate which of the breaks end up being

    // used for the break point for this line.

    curBreak = 0;

    rv = GetTextDimensionsInternal(text, strlen(text), aAvailWidth, utf8Breaks,

                                   aNumBreaks, aDimensions, aNumCharsFit,

                                   aLastWordDimensions, aContext);

    // Figure out which of the breaks we ended up using to convert

    // back to utf16 - start from the end.

    for (PRInt32 i = aNumBreaks - 1; i >= 0; --i) {

        if (utf8Breaks[i] == aNumCharsFit) {

            //      if (aNumCharsFit != aBreaks[i])

            //                printf("Fixing utf8 -> utf16 %d -> %d\n", aNumCharsFit, aBreaks[i]);

            aNumCharsFit = aBreaks[i];

            break;

        }

    }

 loser:

    if (text)

        g_free(text);

    delete[] utf8Breaks;

    return rv;

}

nsresult

nsFontMetricsPango::DrawString(const char *aString, PRUint32 aLength,

                               nscoord aX, nscoord aY,

                               const nscoord* aSpacing,

                               nsRenderingContextGTK *aContext,

                               nsDrawingSurfaceGTK *aSurface)

{

    PangoLayout *layout = pango_layout_new(mPangoContext);

    pango_layout_set_text(layout, aString, aLength);

    int x = aX;

    int y = aY;

    aContext->GetTranMatrix()->TransformCoord(&x, &y);

    PangoLayoutLine *line;

    if (pango_layout_get_line_count(layout) != 1) {

        printf("Warning: more than one line!\n");

    }

    line = pango_layout_get_line(layout, 0);

    aContext->UpdateGC();

    GdkGC *gc = aContext->GetGC();

    if (aSpacing && *aSpacing) {

        DrawStringSlowly(aString, NULL, aLength, aSurface->GetDrawable(),

                         gc, x, y, line, aSpacing);

    }

    else {

        gdk_draw_layout_line(aSurface->GetDrawable(), gc,

                             x, y,

                             line);

    }

    g_object_unref(gc);

    g_object_unref(layout);

    //    printf("DrawString (char *)\n");

    return NS_OK;

}

nsresult

nsFontMetricsPango::DrawString(const PRUnichar* aString, PRUint32 aLength,

                               nscoord aX, nscoord aY,

                               PRInt32 aFontID,

                               const nscoord* aSpacing,

                               nsRenderingContextGTK *aContext,

                               nsDrawingSurfaceGTK *aSurface)

{

    nsresult rv = NS_OK;

    int x = aX;

    int y = aY;

    aContext->UpdateGC();

    GdkGC *gc = aContext->GetGC();

    PangoLayout *layout = pango_layout_new(mPangoContext);

    gchar *text = g_utf16_to_utf8(aString, aLength,

                                  NULL, NULL, NULL);

    if (!text) {

#ifdef DEBUG

        NS_WARNING("nsFontMetricsPango::DrawString invalid unicode to follow");

        DUMP_PRUNICHAR(aString, aLength)

#endif

        rv = NS_ERROR_FAILURE;

        goto loser;

    }

    pango_layout_set_text(layout, text, strlen(text));

    aContext->GetTranMatrix()->TransformCoord(&x, &y);

    PangoLayoutLine *line;

    if (pango_layout_get_line_count(layout) != 1) {

        printf("Warning: more than one line!\n");

    }

    line = pango_layout_get_line(layout, 0);

    if (aSpacing && *aSpacing) {

        DrawStringSlowly(text, aString, aLength, aSurface->GetDrawable(),

                         gc, x, y, line, aSpacing);

    }

    else {

        gdk_draw_layout_line(aSurface->GetDrawable(), gc,

                             x, y,

                             line);

    }

 loser:

    g_free(text);

    g_object_unref(gc);

    g_object_unref(layout);

    //    printf("DrawString\n");

    return rv;

}

#ifdef MOZ_MATHML

nsresult

nsFontMetricsPango::GetBoundingMetrics(const char *aString, PRUint32 aLength,

                                       nsBoundingMetrics &aBoundingMetrics,

                                       nsRenderingContextGTK *aContext)

{

    printf("GetBoundingMetrics (char *)\n");

    return NS_ERROR_FAILURE;

}

nsresult

nsFontMetricsPango::GetBoundingMetrics(const PRUnichar *aString,

                                       PRUint32 aLength,

                                       nsBoundingMetrics &aBoundingMetrics,

                                       PRInt32 *aFontID,

                                       nsRenderingContextGTK *aContext)

{

    nsresult rv = NS_OK;

    PangoLayout *layout = pango_layout_new(mPangoContext);

    gchar *text = g_utf16_to_utf8(aString, aLength,

                                  NULL, NULL, NULL);

    if (!text) {

#ifdef DEBUG

        NS_WARNING("nsFontMetricsPango::GetBoundingMetrics invalid unicode to follow");

        DUMP_PRUNICHAR(aString, aLength)

#endif

        aBoundingMetrics.leftBearing = 0;

        aBoundingMetrics.rightBearing = 0;

        aBoundingMetrics.width = 0;

        aBoundingMetrics.ascent = 0;

        aBoundingMetrics.descent = 0;

        rv = NS_ERROR_FAILURE;

        goto loser;

    }

    pango_layout_set_text(layout, text, strlen(text));

    // Get the logical extents

    PangoLayoutLine *line;

    if (pango_layout_get_line_count(layout) != 1) {

        printf("Warning: more than one line!\n");

    }

    line = pango_layout_get_line(layout, 0);

    // Get the ink extents

    PangoRectangle rect;

    pango_layout_line_get_extents(line, NULL, &rect);

    float P2T;

    P2T = mDeviceContext->DevUnitsToAppUnits();

    aBoundingMetrics.leftBearing =

        NSToCoordRound(rect.x / PANGO_SCALE * P2T);

    aBoundingMetrics.rightBearing =

        NSToCoordRound(rect.width / PANGO_SCALE * P2T);

    aBoundingMetrics.width = NSToCoordRound((rect.x + rect.width) / PANGO_SCALE * P2T);

    aBoundingMetrics.ascent = NSToCoordRound(rect.y / PANGO_SCALE * P2T);

    aBoundingMetrics.descent = NSToCoordRound(rect.height / PANGO_SCALE * P2T);

 loser:

    g_free(text);

    g_object_unref(layout);

    return rv;

}

#endif /* MOZ_MATHML */

GdkFont*

nsFontMetricsPango::GetCurrentGDKFont(void)

{

    return nsnull;

}

nsresult

nsFontMetricsPango::SetRightToLeftText(PRBool aIsRTL)

{

    if (aIsRTL) {

        if (!mRTLPangoContext) {

            mRTLPangoContext = pango_xft_get_context(GDK_DISPLAY(), 0);

            pango_context_set_base_dir(mRTLPangoContext, PANGO_DIRECTION_RTL);

            gdk_pango_context_set_colormap(mRTLPangoContext, gdk_rgb_get_cmap());

            pango_context_set_language(mRTLPangoContext, GetPangoLanguage(mLangGroup));

            pango_context_set_font_description(mRTLPangoContext, mPangoFontDesc);

        }

        mPangoContext = mRTLPangoContext;

    }

    else {

        mPangoContext = mLTRPangoContext;

    }

    mIsRTL = aIsRTL;

    return NS_OK;

}

/* static */

PRUint32

nsFontMetricsPango::GetHints(void)

{

    return (NS_RENDERING_HINT_BIDI_REORDERING |

            NS_RENDERING_HINT_ARABIC_SHAPING | 

            NS_RENDERING_HINT_FAST_MEASURE);

}

/* static */

nsresult

nsFontMetricsPango::FamilyExists(nsIDeviceContext *aDevice,

                                 const nsString &aName)

{

    if (!IsASCIIFontName(aName))

        return NS_ERROR_FAILURE;

    NS_ConvertUCS2toUTF8 name(aName);

    nsresult rv = NS_ERROR_FAILURE;

    PangoContext *context = pango_xft_get_context(GDK_DISPLAY(), 0);

    PangoFontFamily **familyList;

    int n;

    pango_context_list_families(context, &familyList, &n);

    for (int i=0; i < n; i++) {

        const char *tmpname = pango_font_family_get_name(familyList[i]);

        if (!Compare(nsDependentCString(tmpname), name,

                     nsCaseInsensitiveCStringComparator())) {

            rv = NS_OK;

            break;

        }

    }

    g_free(familyList);

    g_object_unref(context);

    return rv;

}

// Private Methods

nsresult

nsFontMetricsPango::RealizeFont(void)

{

    nsCString familyList;

    // Create and fill out the font description.