4597 lines
152 KiB
Diff
4597 lines
152 KiB
Diff
Patch for Firefox 1.5.0.7 to add support for printing via Pango.
|
|
This also implements printing MathML via Pango, and prints bitmap
|
|
fonts too.
|
|
|
|
Authors:
|
|
Behdad Esfahbod
|
|
Chris Blizzard
|
|
Akira TAGOH
|
|
|
|
Index: gfx/src/freetype/nsFreeType.cpp
|
|
===================================================================
|
|
RCS file: /cvsroot/mozilla/gfx/src/freetype/nsFreeType.cpp,v
|
|
retrieving revision 1.28
|
|
diff -u -p -d -r1.28 nsFreeType.cpp
|
|
--- gfx/src/freetype/nsFreeType.cpp 13 Jul 2005 18:21:10 -0000 1.28
|
|
+++ gfx/src/freetype/nsFreeType.cpp 23 Oct 2006 17:37:09 -0000
|
|
@@ -123,6 +123,8 @@ FtFuncList nsFreeType2::FtFuncs [] = {
|
|
// #endif
|
|
{"FT_Get_First_Char", NS_FT2_OFFSET(nsFT_Get_First_Char), PR_FALSE},
|
|
{"FT_Get_Next_Char", NS_FT2_OFFSET(nsFT_Get_Next_Char), PR_FALSE},
|
|
+ {"FT_Has_PS_Glyph_Names", NS_FT2_OFFSET(nsFT_Has_PS_Glyph_Names), PR_FALSE},
|
|
+ {"FT_Get_Glyph_Name", NS_FT2_OFFSET(nsFT_Get_Glyph_Name), PR_TRUE},
|
|
{nsnull, 0, 0}
|
|
};
|
|
|
|
@@ -388,6 +390,22 @@ nsFreeType2::GetNextChar(FT_Face face, F
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
+nsFreeType2::HasPSGlyphNames(FT_Face face, FT_Int *result)
|
|
+{
|
|
+ // call the FreeType2 function via the function pointer
|
|
+ *result = nsFT_Has_PS_Glyph_Names(face);
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+NS_IMETHODIMP
|
|
+nsFreeType2::GetGlyphName(FT_Face face, FT_UInt glyph_index, FT_Pointer buffer, FT_UInt buffer_max)
|
|
+{
|
|
+ // call the FreeType2 function via the function pointer
|
|
+ FT_Error error = nsFT_Get_Glyph_Name(face, glyph_index, buffer, buffer_max);
|
|
+ return error ? NS_ERROR_FAILURE : NS_OK;
|
|
+}
|
|
+
|
|
+NS_IMETHODIMP
|
|
nsFreeType2::SupportsExtFunc(PRBool *res)
|
|
{
|
|
*res = gHasExtFunc;
|
|
Index: gfx/src/freetype/nsFreeType.h
|
|
===================================================================
|
|
RCS file: /cvsroot/mozilla/gfx/src/freetype/nsFreeType.h,v
|
|
retrieving revision 1.18
|
|
diff -u -p -d -r1.18 nsFreeType.h
|
|
--- gfx/src/freetype/nsFreeType.h 1 May 2005 17:36:19 -0000 1.18
|
|
+++ gfx/src/freetype/nsFreeType.h 23 Oct 2006 17:37:09 -0000
|
|
@@ -52,6 +52,7 @@
|
|
#include FT_CACHE_H
|
|
#include FT_CACHE_IMAGE_H
|
|
#include FT_TRUETYPE_TABLES_H
|
|
+#include FT_TYPE1_TABLES_H
|
|
#include "nsIFreeType2.h"
|
|
|
|
typedef struct FT_FaceRec_* FT_Face;
|
|
@@ -138,6 +139,8 @@ typedef FT_Error (*FT_Glyph_To_Bitmap_t)
|
|
|
|
typedef FT_ULong (*FT_Get_First_Char_t)(FT_Face, FT_UInt*);
|
|
typedef FT_ULong (*FT_Get_Next_Char_t)(FT_Face, FT_ULong, FT_UInt*);
|
|
+typedef FT_Int (*FT_Has_PS_Glyph_Names_t)(FT_Face);
|
|
+typedef FT_Error (*FT_Get_Glyph_Name_t)(FT_Face, FT_UInt, FT_Pointer, FT_UInt);
|
|
|
|
class nsFreeTypeFace;
|
|
|
|
@@ -193,11 +196,13 @@ protected:
|
|
// #endif
|
|
FT_Get_First_Char_t nsFT_Get_First_Char;
|
|
FT_Get_Next_Char_t nsFT_Get_Next_Char;
|
|
+ FT_Has_PS_Glyph_Names_t nsFT_Has_PS_Glyph_Names;
|
|
+ FT_Get_Glyph_Name_t nsFT_Get_Glyph_Name;
|
|
|
|
// this array needs to be big enough to hold all the function pointers
|
|
// plus one extra for the null at the end
|
|
// #ifdef MOZ_SVG
|
|
- static FtFuncList FtFuncs[24];
|
|
+ static FtFuncList FtFuncs[28];
|
|
// #else
|
|
// static FtFuncList FtFuncs[20];
|
|
// #endif
|
|
Index: gfx/src/ps/Makefile.in
|
|
===================================================================
|
|
RCS file: /cvsroot/mozilla/gfx/src/ps/Makefile.in,v
|
|
retrieving revision 1.57.8.1
|
|
diff -d -u -p -r1.57.8.1 Makefile.in
|
|
--- gfx/src/ps/Makefile.in 17 Jun 2006 15:16:14 -0000 1.57.8.1
|
|
+++ gfx/src/ps/Makefile.in 24 Oct 2006 18:36:45 -0000
|
|
@@ -98,6 +98,15 @@ EXTRA_DSO_LDOPTS = \
|
|
$(MOZ_UNICHARUTIL_LIBS) \
|
|
$(NULL)
|
|
|
|
+ifdef MOZ_ENABLE_PANGO
|
|
+CPPSRCS += \
|
|
+ nsFontMetricsPSPango.cpp \
|
|
+ mozilla-ps-decoder.cpp
|
|
+EXTRA_DSO_LDOPTS += $(MOZ_PANGO_LIBS)
|
|
+CXXFLAGS += $(MOZ_PANGO_CFLAGS)
|
|
+CFLAGS += $(MOZ_PANGO_CFLAGS)
|
|
+endif
|
|
+
|
|
ifdef MOZ_ENABLE_XFT
|
|
EXTRA_DSO_LDOPTS += \
|
|
$(MOZ_XFT_LIBS) \
|
|
@@ -105,7 +114,7 @@ EXTRA_DSO_LDOPTS += \
|
|
$(NULL)
|
|
endif
|
|
|
|
-ifneq (,$(MOZ_ENABLE_FREETYPE2)$(MOZ_ENABLE_XFT))
|
|
+ifneq (,$(MOZ_ENABLE_FREETYPE2)$(MOZ_ENABLE_XFT)$(MOZ_ENABLE_PANGO))
|
|
CPPSRCS += \
|
|
nsType1.cpp \
|
|
$(NULL)
|
|
Index: gfx/src/ps/mozilla-ps-decoder.cpp
|
|
===================================================================
|
|
RCS file: gfx/src/ps/mozilla-ps-decoder.cpp
|
|
diff -N gfx/src/ps/mozilla-ps-decoder.cpp
|
|
--- /dev/null 1 Jan 1970 00:00:00 -0000
|
|
+++ gfx/src/ps/mozilla-ps-decoder.cpp 23 Oct 2006 17:37:10 -0000
|
|
@@ -0,0 +1,376 @@
|
|
+/* -*- 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-ps-decoder.h"
|
|
+#include <pango/pangofc-fontmap.h>
|
|
+#include <pango/pangofc-font.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 (MozillaPSDecoder, mozilla_ps_decoder, PANGO_TYPE_FC_DECODER)
|
|
+
|
|
+MozillaPSDecoder *mozilla_ps_decoder_new (void);
|
|
+
|
|
+static FcCharSet *mozilla_ps_decoder_get_charset (PangoFcDecoder *decoder,
|
|
+ PangoFcFont *fcfont);
|
|
+static PangoGlyph mozilla_ps_decoder_get_glyph (PangoFcDecoder *decoder,
|
|
+ PangoFcFont *fcfont,
|
|
+ guint32 wc);
|
|
+
|
|
+static PangoFcDecoder *mozilla_find_ps_decoder (FcPattern *pattern,
|
|
+ gpointer user_data);
|
|
+
|
|
+typedef struct _MozillaPSDecoderPrivate MozillaPSDecoderPrivate;
|
|
+
|
|
+#define MOZILLA_PS_DECODER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), MOZILLA_TYPE_DECODER, MozillaPSDecoderPrivate))
|
|
+
|
|
+struct _MozillaPSDecoderPrivate {
|
|
+ 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.
|
|
+static GHashTable *encoder_hash = NULL;
|
|
+static GHashTable *cmap_hash = NULL;
|
|
+static GHashTable *wide_hash = NULL;
|
|
+
|
|
+void
|
|
+mozilla_ps_decoder_init (MozillaPSDecoder *decoder)
|
|
+{
|
|
+}
|
|
+
|
|
+void
|
|
+mozilla_ps_decoder_class_init (MozillaPSDecoderClass *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_ps_decoder_get_charset;
|
|
+ parent_class->get_glyph = mozilla_ps_decoder_get_glyph;
|
|
+
|
|
+ g_type_class_add_private (object_class, sizeof (MozillaPSDecoderPrivate));
|
|
+}
|
|
+
|
|
+MozillaPSDecoder *
|
|
+mozilla_ps_decoder_new(void)
|
|
+{
|
|
+ return (MozillaPSDecoder *)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_ps_decoders_init:
|
|
+ *
|
|
+ * #mozilla_ps_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_ps_decoders_init(PangoFontMap *fontmap)
|
|
+{
|
|
+ static PRBool initialized = PR_FALSE;
|
|
+ if (initialized)
|
|
+ return 0;
|
|
+
|
|
+ if (!PANGO_IS_FC_FONT_MAP (fontmap))
|
|
+ return -1;
|
|
+
|
|
+ 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(fontmap),
|
|
+ mozilla_find_ps_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;
|
|
+}
|
|
+
|
|
+static FcCharSet *
|
|
+mozilla_ps_decoder_get_charset (PangoFcDecoder *decoder,
|
|
+ PangoFcFont *fcfont)
|
|
+{
|
|
+ MozillaPSDecoderPrivate *priv = MOZILLA_PS_DECODER_GET_PRIVATE(decoder);
|
|
+
|
|
+ if (priv->charset)
|
|
+ return priv->charset;
|
|
+
|
|
+ // First time this has been accessed. Populate the charset.
|
|
+ priv->charset = FcCharSetCreate();
|
|
+
|
|
+ if (!gCharsetManager) {
|
|
+ CallGetService(kCharsetConverterManagerCID, &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;
|
|
+}
|
|
+
|
|
+static PangoGlyph
|
|
+mozilla_ps_decoder_get_glyph (PangoFcDecoder *decoder,
|
|
+ PangoFcFont *fcfont,
|
|
+ guint32 wc)
|
|
+{
|
|
+ MozillaPSDecoderPrivate *priv = MOZILLA_PS_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_ps_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;
|
|
+}
|
|
+
|
|
+static PangoFcDecoder *
|
|
+mozilla_find_ps_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;
|
|
+
|
|
+ MozillaPSDecoder *decoder = mozilla_ps_decoder_new();
|
|
+
|
|
+ MozillaPSDecoderPrivate *priv = MOZILLA_PS_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);
|
|
+}
|
|
Index: gfx/src/ps/mozilla-ps-decoder.h
|
|
===================================================================
|
|
RCS file: gfx/src/ps/mozilla-ps-decoder.h
|
|
diff -N gfx/src/ps/mozilla-ps-decoder.h
|
|
--- /dev/null 1 Jan 1970 00:00:00 -0000
|
|
+++ gfx/src/ps/mozilla-ps-decoder.h 23 Oct 2006 17:37:10 -0000
|
|
@@ -0,0 +1,72 @@
|
|
+/* -*- 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_PS_DECODER_H
|
|
+#define _MOZILLA_PS_DECODER_H
|
|
+
|
|
+#include <pango/pangofc-decoder.h>
|
|
+
|
|
+G_BEGIN_DECLS
|
|
+
|
|
+#define MOZILLA_TYPE_DECODER (mozilla_ps_decoder_get_type())
|
|
+#define MOZILLA_PS_DECODER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), MOZILLA_TYPE_DECODER, MozillaPSDecoder))
|
|
+#define MOZILLA_IS_DECODER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), MOZILLA_TYPE_DECODER))
|
|
+
|
|
+typedef struct _MozillaPSDecoder MozillaPSDecoder;
|
|
+typedef struct _MozillaPSDecoderClass MozillaPSDecoderClass;
|
|
+
|
|
+#define MOZILLA_PS_DECODER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MOZILLA_TYPE_DECODER, MozillaPSDecoderClass))
|
|
+#define MOZILLA_IS_DECODER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOZILLA_TYPE_DECODER))
|
|
+#define MOZILLA_PS_DECODER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOZILLA_TYPE_DECODER, MozillaPSDecoderClass))
|
|
+
|
|
+struct _MozillaPSDecoder
|
|
+{
|
|
+ PangoFcDecoder parent_instance;
|
|
+};
|
|
+
|
|
+struct _MozillaPSDecoderClass
|
|
+{
|
|
+ PangoFcDecoderClass parent_class;
|
|
+};
|
|
+
|
|
+GType mozilla_ps_decoder_get_type (void);
|
|
+int mozilla_ps_decoders_init (PangoFontMap *fontmap);
|
|
+
|
|
+G_END_DECLS
|
|
+
|
|
+#endif /*_MOZILLA_PS_DECODER_H */
|
|
Index: gfx/src/ps/nsDeviceContextPS.cpp
|
|
===================================================================
|
|
RCS file: /cvsroot/mozilla/gfx/src/ps/nsDeviceContextPS.cpp,v
|
|
retrieving revision 1.73
|
|
diff -u -p -d -r1.73 nsDeviceContextPS.cpp
|
|
--- gfx/src/ps/nsDeviceContextPS.cpp 21 May 2005 15:33:08 -0000 1.73
|
|
+++ gfx/src/ps/nsDeviceContextPS.cpp 23 Oct 2006 17:37:10 -0000
|
|
@@ -58,12 +58,15 @@
|
|
#include "nsIPref.h"
|
|
#include "nsString.h"
|
|
#include "nsFontMetricsPS.h"
|
|
+#ifdef MOZ_ENABLE_PANGO
|
|
+#include "nsFontMetricsPSPango.h"
|
|
+#endif
|
|
#include "nsPostScriptObj.h"
|
|
#include "nspr.h"
|
|
#include "nsILanguageAtomService.h"
|
|
#include "nsPrintJobPS.h"
|
|
#include "nsPrintJobFactoryPS.h"
|
|
-#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
|
|
+#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
#include "nsType1.h"
|
|
#endif
|
|
|
|
@@ -223,7 +226,7 @@ nsDeviceContextPS::InitDeviceContextPS(n
|
|
|
|
nsresult rv;
|
|
nsCOMPtr<nsIPref> pref(do_GetService(NS_PREF_CONTRACTID, &rv));
|
|
-#ifdef MOZ_ENABLE_XFT
|
|
+#if defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = pref->GetBoolPref("font.FreeType2.printing", &mFTPEnable);
|
|
if (NS_FAILED(rv))
|
|
@@ -469,7 +472,7 @@ NS_IMETHODIMP nsDeviceContextPS::EndDocu
|
|
NS_ASSERTION(submitFP, "No print job submission handle");
|
|
|
|
// Start writing the print job to the job handler
|
|
-#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
|
|
+#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
mPSObj->write_prolog(submitFP, mFTPEnable);
|
|
#else
|
|
mPSObj->write_prolog(submitFP);
|
|
@@ -550,15 +553,52 @@ public:
|
|
virtual nsresult CreateFontMetricsInstance(nsIFontMetrics** aResult);
|
|
};
|
|
|
|
+#if defined(MOZ_ENABLE_PANGO)
|
|
+PRBool
|
|
+NS_IsPangoEnabled(void)
|
|
+{
|
|
+ static PRBool beenHere;
|
|
+ static PRBool pangoEnabled;
|
|
+
|
|
+ if (!beenHere) {
|
|
+ beenHere = PR_TRUE;
|
|
+
|
|
+ char *val = PR_GetEnv("MOZ_DISABLE_PANGO");
|
|
+ pangoEnabled = !(val);
|
|
+
|
|
+ if (pangoEnabled) {
|
|
+ nsCOMPtr<nsIPref> prefService = do_GetService(NS_PREF_CONTRACTID);
|
|
+ if (prefService)
|
|
+ prefService->SetDefaultCharPref("general.useragent.extra.pango",
|
|
+ "pango-text");
|
|
+ }
|
|
+ }
|
|
+
|
|
+ return pangoEnabled;
|
|
+}
|
|
+#endif
|
|
|
|
nsresult nsFontCachePS::CreateFontMetricsInstance(nsIFontMetrics** aResult)
|
|
{
|
|
NS_PRECONDITION(aResult, "null out param");
|
|
- nsIFontMetrics *fm = new nsFontMetricsPS();
|
|
- if (!fm)
|
|
- return NS_ERROR_OUT_OF_MEMORY;
|
|
- NS_ADDREF(fm);
|
|
- *aResult = fm;
|
|
+#ifdef MOZ_ENABLE_PANGO
|
|
+ if (NS_IsPangoEnabled())
|
|
+ {
|
|
+ nsIFontMetrics *fm = new nsFontMetricsPSPango();
|
|
+ if (!fm)
|
|
+ return NS_ERROR_OUT_OF_MEMORY;
|
|
+ NS_ADDREF(fm);
|
|
+ *aResult = fm;
|
|
+ }
|
|
+ else
|
|
+#endif
|
|
+ {
|
|
+ nsIFontMetrics *fm = new nsFontMetricsPS();
|
|
+ if (!fm)
|
|
+ return NS_ERROR_OUT_OF_MEMORY;
|
|
+ NS_ADDREF(fm);
|
|
+ *aResult = fm;
|
|
+ }
|
|
return NS_OK;
|
|
}
|
|
|
|
Index: gfx/src/ps/nsFontMetricsPS.cpp
|
|
===================================================================
|
|
RCS file: /cvsroot/mozilla/gfx/src/ps/nsFontMetricsPS.cpp,v
|
|
retrieving revision 1.57.16.2
|
|
diff -u -p -d -r1.57.16.2 nsFontMetricsPS.cpp
|
|
--- gfx/src/ps/nsFontMetricsPS.cpp 7 May 2006 02:01:25 -0000 1.57.16.2
|
|
+++ gfx/src/ps/nsFontMetricsPS.cpp 23 Oct 2006 17:37:11 -0000
|
|
@@ -461,6 +461,239 @@ nsFontMetricsPS :: GetStringWidth(const
|
|
return NS_OK;
|
|
}
|
|
|
|
+nsresult
|
|
+nsFontMetricsPS::DrawString(const char *aString, PRUint32 aLength,
|
|
+ nscoord aX, nscoord aY,
|
|
+ const nscoord* aSpacing,
|
|
+ nsRenderingContextPS *aContext)
|
|
+{
|
|
+ nsPostScriptObj* psObj = aContext->GetPostScriptObj();
|
|
+ // When FT2 printing is enabled, we don't need to set langgroup
|
|
+#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
|
|
+ if (!NS_REINTERPRET_CAST(nsDeviceContextPS *, GetDeviceContext())->mFTPEnable) {
|
|
+#endif
|
|
+ nsCOMPtr<nsIAtom> langGroup;
|
|
+ GetLangGroup(getter_AddRefs(langGroup));
|
|
+ psObj->setlanggroup(langGroup);
|
|
+#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
|
|
+ }
|
|
+#endif
|
|
+
|
|
+ if (aLength == 0)
|
|
+ return NS_OK;
|
|
+ nsFontPS* fontPS = nsFontPS::FindFont(aString[0], Font(), this);
|
|
+ NS_ENSURE_TRUE(fontPS, NS_ERROR_FAILURE);
|
|
+ fontPS->SetupFont(aContext);
|
|
+
|
|
+ PRUint32 i, start = 0;
|
|
+ for (i=0; i<aLength; i++) {
|
|
+ nsFontPS* fontThisChar;
|
|
+ fontThisChar = nsFontPS::FindFont(aString[i], Font(), this);
|
|
+ NS_ENSURE_TRUE(fontThisChar, NS_ERROR_FAILURE);
|
|
+ if (fontThisChar != fontPS) {
|
|
+ // draw text up to this point
|
|
+ aX += DrawString(aString+start, i-start, aX, aY, fontPS,
|
|
+ aSpacing?aSpacing+start:nsnull, aContext);
|
|
+ start = i;
|
|
+
|
|
+ // setup for following text
|
|
+ fontPS = fontThisChar;
|
|
+ fontPS->SetupFont(aContext);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ // draw the last part
|
|
+ if (aLength-start)
|
|
+ DrawString(aString+start, aLength-start, aX, aY, fontPS,
|
|
+ aSpacing?aSpacing+start:nsnull, aContext);
|
|
+
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPS::DrawString(const PRUnichar* aString, PRUint32 aLength,
|
|
+ nscoord aX, nscoord aY,
|
|
+ PRInt32 aFontID,
|
|
+ const nscoord* aSpacing,
|
|
+ nsRenderingContextPS *aContext)
|
|
+{
|
|
+ nsPostScriptObj* psObj = aContext->GetPostScriptObj();
|
|
+#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
|
|
+ // When FT2 printing is enabled, we don't need to set langgroup
|
|
+ if (!NS_REINTERPRET_CAST(nsDeviceContextPS *, GetDeviceContext())->mFTPEnable) {
|
|
+#endif
|
|
+ nsCOMPtr<nsIAtom> langGroup = nsnull;
|
|
+ GetLangGroup(getter_AddRefs(langGroup));
|
|
+ psObj->setlanggroup(langGroup);
|
|
+#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
|
|
+ }
|
|
+#endif
|
|
+
|
|
+ /* build up conversion table */
|
|
+ psObj->preshow(aString, aLength);
|
|
+
|
|
+ if (aLength == 0)
|
|
+ return NS_OK;
|
|
+ nsFontPS* fontPS = nsFontPS::FindFont(aString[0], Font(), this);
|
|
+ NS_ENSURE_TRUE(fontPS, NS_ERROR_FAILURE);
|
|
+ fontPS->SetupFont(aContext);
|
|
+
|
|
+ PRUint32 i, start = 0;
|
|
+ for (i=0; i<aLength; i++) {
|
|
+ nsFontPS* fontThisChar;
|
|
+ fontThisChar = nsFontPS::FindFont(aString[i], Font(), this);
|
|
+ NS_ENSURE_TRUE(fontThisChar, NS_ERROR_FAILURE);
|
|
+ if (fontThisChar != fontPS) {
|
|
+ // draw text up to this point
|
|
+ aX += DrawString(aString+start, i-start, aX, aY, fontPS,
|
|
+ aSpacing?aSpacing+start:nsnull, aContext);
|
|
+ start = i;
|
|
+
|
|
+ // setup for following text
|
|
+ fontPS = fontThisChar;
|
|
+ fontPS->SetupFont(aContext);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ // draw the last part
|
|
+ if (aLength-start)
|
|
+ DrawString(aString+start, aLength-start, aX, aY, fontPS,
|
|
+ aSpacing?aSpacing+start:nsnull, aContext);
|
|
+
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+PRInt32
|
|
+nsFontMetricsPS::DrawString(const char *aString, PRUint32 aLength,
|
|
+ nscoord aX, nscoord aY, nsFontPS* aFontPS,
|
|
+ const nscoord* aSpacing,
|
|
+ nsRenderingContextPS *aContext)
|
|
+{
|
|
+ nscoord width = 0;
|
|
+ PRInt32 x = aX;
|
|
+ PRInt32 y = aY;
|
|
+
|
|
+ PRInt32 dxMem[500];
|
|
+ PRInt32* dx0 = 0;
|
|
+ if (aSpacing) {
|
|
+ dx0 = dxMem;
|
|
+ if (aLength > 500) {
|
|
+ dx0 = new PRInt32[aLength];
|
|
+ NS_ENSURE_TRUE(dx0, NS_ERROR_OUT_OF_MEMORY);
|
|
+ }
|
|
+ aContext->GetTranMatrix()->ScaleXCoords(aSpacing, aLength, dx0);
|
|
+ }
|
|
+
|
|
+ aContext->GetTranMatrix()->TransformCoord(&x, &y);
|
|
+ width = aFontPS->DrawString(aContext, x, y, aString, aLength);
|
|
+
|
|
+ if ((aSpacing) && (dx0 != dxMem)) {
|
|
+ delete [] dx0;
|
|
+ }
|
|
+
|
|
+ return width;
|
|
+}
|
|
+
|
|
+
|
|
+PRInt32
|
|
+nsFontMetricsPS::DrawString(const PRUnichar* aString, PRUint32 aLength,
|
|
+ nscoord &aX, nscoord &aY, nsFontPS* aFontPS,
|
|
+ const nscoord* aSpacing,
|
|
+ nsRenderingContextPS *aContext)
|
|
+{
|
|
+ nscoord width = 0;
|
|
+ PRInt32 x = aX;
|
|
+ PRInt32 y = aY;
|
|
+
|
|
+ if (aSpacing) {
|
|
+ // Slow, but accurate rendering
|
|
+ const PRUnichar* end = aString + aLength;
|
|
+ while (aString < end){
|
|
+ x = aX;
|
|
+ y = aY;
|
|
+ aContext->GetTranMatrix()->TransformCoord(&x, &y);
|
|
+ aFontPS->DrawString(aContext, x, y, aString, 1);
|
|
+ aX += *aSpacing++;
|
|
+ aString++;
|
|
+ }
|
|
+ width = aX;
|
|
+ } else {
|
|
+ aContext->GetTranMatrix()->TransformCoord(&x, &y);
|
|
+ width = aFontPS->DrawString(aContext, x, y, aString, aLength);
|
|
+ }
|
|
+
|
|
+ return width;
|
|
+}
|
|
+
|
|
+NS_IMETHODIMP
|
|
+nsFontMetricsPS::GetTextDimensions(const char* aString,
|
|
+ PRInt32 aLength,
|
|
+ PRInt32 aAvailWidth,
|
|
+ PRInt32* aBreaks,
|
|
+ PRInt32 aNumBreaks,
|
|
+ nsTextDimensions& aDimensions,
|
|
+ PRInt32& aNumCharsFit,
|
|
+ nsTextDimensions& aLastWordDimensions,
|
|
+ PRInt32* aFontID)
|
|
+{
|
|
+ NS_NOTYETIMPLEMENTED("nsFontMetricsPS::GetTextDimensions");
|
|
+ return NS_ERROR_NOT_IMPLEMENTED;
|
|
+}
|
|
+
|
|
+NS_IMETHODIMP
|
|
+nsFontMetricsPS::GetTextDimensions(const PRUnichar* aString,
|
|
+ PRInt32 aLength,
|
|
+ PRInt32 aAvailWidth,
|
|
+ PRInt32* aBreaks,
|
|
+ PRInt32 aNumBreaks,
|
|
+ nsTextDimensions& aDimensions,
|
|
+ PRInt32& aNumCharsFit,
|
|
+ nsTextDimensions& aLastWordDimensions,
|
|
+ PRInt32* aFontID)
|
|
+{
|
|
+ NS_NOTYETIMPLEMENTED("nsFontMetricsPS::GetTextDimensions");
|
|
+ return NS_ERROR_NOT_IMPLEMENTED;
|
|
+}
|
|
+
|
|
+NS_IMETHODIMP
|
|
+nsFontMetricsPS :: GetTextDimensions(const char* aString, PRUint32 aLength,
|
|
+ nsTextDimensions& aDimensions)
|
|
+{
|
|
+ GetStringWidth(aString, aDimensions.width, aLength);
|
|
+ GetMaxAscent(aDimensions.ascent);
|
|
+ GetMaxDescent(aDimensions.descent);
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+NS_IMETHODIMP
|
|
+nsFontMetricsPS :: GetTextDimensions(const PRUnichar* aString, PRUint32 aLength,
|
|
+ nsTextDimensions& aDimensions, PRInt32* aFontID)
|
|
+{
|
|
+ GetStringWidth(aString, aDimensions.width, aLength);
|
|
+ //XXX temporary - bug 96609
|
|
+ GetMaxAscent(aDimensions.ascent);
|
|
+ GetMaxDescent(aDimensions.descent);
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPS::GetBoundingMetrics(const char* aString,
|
|
+ PRUint32 aLength,
|
|
+ nsBoundingMetrics& aBoundingMetrics)
|
|
+{
|
|
+ return NS_ERROR_NOT_IMPLEMENTED;
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPS::GetBoundingMetrics(const PRUnichar* aString,
|
|
+ PRUint32 aLength,
|
|
+ nsBoundingMetrics &aBoundingMetrics,
|
|
+ PRInt32 *aFontID)
|
|
+{
|
|
+ return NS_ERROR_NOT_IMPLEMENTED;
|
|
+}
|
|
+
|
|
+
|
|
nsFontPS*
|
|
nsFontPS::FindFont(char aChar, const nsFont& aFont,
|
|
nsFontMetricsPS* aFontMetrics)
|
|
@@ -1128,23 +1361,38 @@ nsFontPSXft::DrawString(nsRenderingConte
|
|
PRUint32 start = 0;
|
|
PRUint32 i;
|
|
|
|
+ FT_Face face = getFTFace();
|
|
+ if (!face) {
|
|
+ NS_WARNING("Failed to get FT Face in nsFontPSXft::DrawString\n");
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ nsValueArray glyphs(PR_UINT16_MAX);
|
|
+
|
|
// XXX : ignore surrogate pairs for now
|
|
- nsString *subSet = mPSFontGenerator->GetSubset();
|
|
for (i = 0; i < aLength; ++i) {
|
|
- currSubFont = mPSFontGenerator->AddToSubset(aString[i]);
|
|
+ PRUint32 glyph = FT_Get_Char_Index(face, aString[i]);
|
|
+ currSubFont = mPSFontGenerator->AddToGlyphSubset(glyph);
|
|
+
|
|
+ // Check if we need to render the current string
|
|
if (prevSubFont != currSubFont) {
|
|
- if (prevSubFont != -1)
|
|
- psObj->show(&aString[start], i - start, *subSet, prevSubFont);
|
|
+ if (prevSubFont != -1) {
|
|
+ psObj->show(&glyphs, mPSFontGenerator, prevSubFont);
|
|
+ }
|
|
NS_ASSERTION(!mFontNameBase.IsEmpty(),
|
|
"font base name shouldn't be empty");
|
|
psObj->setfont(mFontNameBase, mHeight, currSubFont);
|
|
prevSubFont = currSubFont;
|
|
start = i;
|
|
+ glyphs.Clear();
|
|
}
|
|
+
|
|
+ glyphs.AppendValue(glyph);
|
|
}
|
|
|
|
- if (prevSubFont != -1)
|
|
- psObj->show(&aString[start], i - start, *subSet, prevSubFont);
|
|
+ if (prevSubFont != -1) {
|
|
+ psObj->show(&glyphs, mPSFontGenerator, prevSubFont);
|
|
+ }
|
|
|
|
return GetWidth(aString, aLength);
|
|
}
|
|
@@ -2278,10 +2526,13 @@ nsFontPSFreeType::GetBoundingMetrics(con
|
|
// Implementation of nsPSFontGenerator
|
|
nsPSFontGenerator::nsPSFontGenerator()
|
|
{
|
|
+ mGlyphSubset = new nsValueArray(PR_UINT16_MAX, 40);
|
|
}
|
|
|
|
nsPSFontGenerator::~nsPSFontGenerator()
|
|
{
|
|
+ if (mGlyphSubset)
|
|
+ delete mGlyphSubset;
|
|
}
|
|
|
|
void nsPSFontGenerator::GeneratePSFont(FILE* aFile)
|
|
@@ -2289,24 +2540,29 @@ void nsPSFontGenerator::GeneratePSFont(F
|
|
NS_ERROR("should never call nsPSFontGenerator::GeneratePSFont");
|
|
}
|
|
|
|
-// Add a Unicode character to mSubset which will be divided into
|
|
-// multiple chunks (subfonts) of 255 (kSubFontSize) characters each.
|
|
-// Each chunk will be converted to a Type 1 font. Return the index of
|
|
-// a subfont (chunk) this character belongs to.
|
|
+// Add a glyph offset to mSubset which will be divided into multiple
|
|
+// chunks (subfonts) of 255 (kSubFontSize) glyphs each. Each chunk
|
|
+// will then be converted into a Type 1 font. Return the index of a
|
|
+// subfont (chunk) this glyph belongs to.
|
|
PRInt32
|
|
-nsPSFontGenerator::AddToSubset(PRUnichar aChar)
|
|
+nsPSFontGenerator::AddToGlyphSubset(PRUint32 aGlyph)
|
|
{
|
|
- PRInt32 index = mSubset.FindChar(aChar);
|
|
- if (index == kNotFound) {
|
|
- mSubset.Append(aChar);
|
|
- index = mSubset.Length() - 1;
|
|
+ nsValueArrayIndex index = mGlyphSubset->IndexOf(aGlyph);
|
|
+ if (index == NSVALUEARRAY_INVALID) {
|
|
+ mGlyphSubset->AppendValue(aGlyph);
|
|
+ index = mGlyphSubset->Count() - 1;
|
|
}
|
|
+
|
|
return index / kSubFontSize;
|
|
}
|
|
|
|
-nsString *nsPSFontGenerator::GetSubset()
|
|
+PRInt32
|
|
+nsPSFontGenerator::InSubsetIndexOf(PRUint32 aGlyph)
|
|
{
|
|
- return &mSubset;
|
|
+ nsValueArrayIndex index = mGlyphSubset->IndexOf(aGlyph);
|
|
+ if (index == NSVALUEARRAY_INVALID)
|
|
+ return 0;
|
|
+ return (index % kSubFontSize) + 1;
|
|
}
|
|
|
|
#ifdef MOZ_ENABLE_XFT
|
|
@@ -2332,8 +2588,8 @@ nsXftType1Generator::Init(nsXftEntry* aE
|
|
|
|
nsXftType1Generator::~nsXftType1Generator()
|
|
{
|
|
- if (mEntry->mFace)
|
|
- FT_Done_Face(mEntry->mFace);
|
|
+ if (mEntry->mFace)
|
|
+ FT_Done_Face(mEntry->mFace);
|
|
|
|
if (FT_Done_FreeType(mFreeTypeLibrary))
|
|
return;
|
|
@@ -2353,8 +2609,8 @@ void nsXftType1Generator::GeneratePSFont
|
|
}
|
|
|
|
int wmode = 0;
|
|
- if (!mSubset.IsEmpty())
|
|
- FT2SubsetToType1FontSet(face, mSubset, wmode, aFile);
|
|
+ if (mGlyphSubset->Count())
|
|
+ FT2SubsetToType1FontSet(face, mGlyphSubset, wmode, aFile);
|
|
}
|
|
|
|
#else
|
|
@@ -2402,8 +2658,8 @@ void nsFT2Type1Generator::GeneratePSFont
|
|
return;
|
|
|
|
int wmode = 0;
|
|
- if (!mSubset.IsEmpty())
|
|
- FT2SubsetToType1FontSet(face, mSubset, wmode, aFile);
|
|
+ if (mGlyphSubset->Count())
|
|
+ FT2SubsetToType1FontSet(face, mGlyphSubset, wmode, aFile);
|
|
}
|
|
|
|
#endif //MOZ_ENABLE_FREETYPE2
|
|
Index: gfx/src/ps/nsFontMetricsPS.h
|
|
===================================================================
|
|
RCS file: /cvsroot/mozilla/gfx/src/ps/nsFontMetricsPS.h,v
|
|
retrieving revision 1.31
|
|
diff -u -p -d -r1.31 nsFontMetricsPS.h
|
|
--- gfx/src/ps/nsFontMetricsPS.h 28 Jun 2005 18:29:10 -0000 1.31
|
|
+++ gfx/src/ps/nsFontMetricsPS.h 23 Oct 2006 17:37:11 -0000
|
|
@@ -66,6 +66,7 @@
|
|
#endif
|
|
#include "nsVoidArray.h"
|
|
#include "nsHashtable.h"
|
|
+#include "nsValueArray.h"
|
|
|
|
class nsPSFontGenerator;
|
|
class nsDeviceContextPS;
|
|
@@ -108,6 +109,65 @@ public:
|
|
NS_IMETHOD GetFontHandle(nsFontHandle &aHandle);
|
|
NS_IMETHOD GetStringWidth(const char *String,nscoord &aWidth,nscoord aLength);
|
|
NS_IMETHOD GetStringWidth(const PRUnichar *aString,nscoord &aWidth,nscoord aLength);
|
|
+
|
|
+ NS_IMETHOD GetTextDimensions(const char* aString,
|
|
+ PRUint32 aLength,
|
|
+ nsTextDimensions& aDimensions);
|
|
+ NS_IMETHOD GetTextDimensions(const PRUnichar* aString,
|
|
+ PRUint32 aLength,
|
|
+ nsTextDimensions& aDimensions,
|
|
+ PRInt32* aFontID);
|
|
+ NS_IMETHOD GetTextDimensions(const char* aString,
|
|
+ PRInt32 aLength,
|
|
+ PRInt32 aAvailWidth,
|
|
+ PRInt32* aBreaks,
|
|
+ PRInt32 aNumBreaks,
|
|
+ nsTextDimensions& aDimensions,
|
|
+ PRInt32& aNumCharsFit,
|
|
+ nsTextDimensions& aLastWordDimensions,
|
|
+ PRInt32* aFontID);
|
|
+ NS_IMETHOD GetTextDimensions(const PRUnichar* aString,
|
|
+ PRInt32 aLength,
|
|
+ PRInt32 aAvailWidth,
|
|
+ PRInt32* aBreaks,
|
|
+ PRInt32 aNumBreaks,
|
|
+ nsTextDimensions& aDimensions,
|
|
+ PRInt32& aNumCharsFit,
|
|
+ nsTextDimensions& aLastWordDimensions,
|
|
+ PRInt32* aFontID);
|
|
+#ifdef MOZ_MATHML
|
|
+ NS_IMETHOD GetBoundingMetrics(const char *aString, PRUint32 aLength,
|
|
+ nsBoundingMetrics &aBoundingMetrics);
|
|
+ NS_IMETHOD GetBoundingMetrics(const PRUnichar *aString,
|
|
+ PRUint32 aLength,
|
|
+ nsBoundingMetrics &aBoundingMetrics,
|
|
+ PRInt32 *aFontID);
|
|
+#endif /* MOZ_MATHML */
|
|
+
|
|
+ NS_IMETHOD DrawString(const char *aString, PRUint32 aLength,
|
|
+ nscoord aX, nscoord aY,
|
|
+ const nscoord* aSpacing,
|
|
+ nsRenderingContextPS *aContext);
|
|
+ NS_IMETHOD DrawString(const PRUnichar *aString, PRUint32 aLength,
|
|
+ nscoord aX, nscoord aY,
|
|
+ PRInt32 aFontID,
|
|
+ const nscoord* aSpacing,
|
|
+ nsRenderingContextPS *aContext);
|
|
+
|
|
+protected:
|
|
+ PRInt32 DrawString(const char *aString, PRUint32 aLength,
|
|
+ nscoord aX, nscoord aY, nsFontPS* aFontPS,
|
|
+ const nscoord* aSpacing,
|
|
+ nsRenderingContextPS *aContext);
|
|
+ PRInt32 DrawString(const PRUnichar *aString, PRUint32 aLength,
|
|
+ nscoord &aX, nscoord &aY, nsFontPS* aFontPS,
|
|
+ const nscoord* aSpacing,
|
|
+ nsRenderingContextPS *aContext);
|
|
+
|
|
+public:
|
|
+
|
|
+ virtual PRUint32 GetHints (void) { return 0; }
|
|
+
|
|
|
|
inline void SetXHeight(nscoord aXHeight) { mXHeight = aXHeight; };
|
|
inline void SetSuperscriptOffset(nscoord aSuperscriptOffset) { mSuperscriptOffset = aSuperscriptOffset; };
|
|
@@ -455,16 +515,14 @@ public:
|
|
nsPSFontGenerator();
|
|
virtual ~nsPSFontGenerator();
|
|
virtual void GeneratePSFont(FILE* aFile);
|
|
- PRInt32 AddToSubset(PRUnichar aChar);
|
|
- nsString *GetSubset();
|
|
+ PRInt32 AddToGlyphSubset(PRUint32 aGlyph);
|
|
+ PRInt32 InSubsetIndexOf(PRUint32 aGlyph);
|
|
|
|
// 256 (PS type 1 encoding vector size) - 1 (1 is for mandatory /.notdef)
|
|
const static PRUint16 kSubFontSize;
|
|
|
|
protected:
|
|
- // XXX To support non-BMP characters, we may have to use
|
|
- // nsValueArray with PRUint32
|
|
- nsString mSubset;
|
|
+ nsValueArray *mGlyphSubset;
|
|
};
|
|
|
|
|
|
Index: gfx/src/ps/nsFontMetricsPSPango.cpp
|
|
===================================================================
|
|
RCS file: gfx/src/ps/nsFontMetricsPSPango.cpp
|
|
diff -N gfx/src/ps/nsFontMetricsPSPango.cpp
|
|
--- /dev/null 1 Jan 1970 00:00:00 -0000
|
|
+++ gfx/src/ps/nsFontMetricsPSPango.cpp 23 Oct 2006 17:37:13 -0000
|
|
@@ -0,0 +1,2107 @@
|
|
+/* -*- 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):
|
|
+ * Christopher Blizzard <blizzard@mozilla.org>
|
|
+ * Behdad Esfahbod <behdad@behdad.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 ***** */
|
|
+
|
|
+#include <strings.h>
|
|
+#include "nsFont.h"
|
|
+#include "nsIDeviceContext.h"
|
|
+#include "nsICharsetConverterManager.h"
|
|
+#include "nsIPref.h"
|
|
+#include "nsServiceManagerUtils.h"
|
|
+
|
|
+#define PANGO_ENABLE_BACKEND
|
|
+#define PANGO_ENABLE_ENGINE
|
|
+
|
|
+#include "nsFontMetricsPSPango.h"
|
|
+#include "nsRenderingContextPS.h"
|
|
+#include "nsDeviceContextPS.h"
|
|
+#include "nsFontConfigUtils.h"
|
|
+
|
|
+#include "nsPrintfCString.h"
|
|
+#include "nsUnicharUtils.h"
|
|
+#include "nsQuickSort.h"
|
|
+#include "nsFontConfigUtils.h"
|
|
+
|
|
+#include <fontconfig/fontconfig.h>
|
|
+#include <pango/pangoft2.h>
|
|
+#include <freetype/tttables.h>
|
|
+#include "nsType1.h"
|
|
+
|
|
+#include "mozilla-ps-decoder.h"
|
|
+
|
|
+#define FORCE_PR_LOG
|
|
+#include "prlog.h"
|
|
+
|
|
+// Globals
|
|
+
|
|
+static PRLogModuleInfo *gPangoFontLog;
|
|
+static int gNumInstances;
|
|
+
|
|
+
|
|
+static void
|
|
+default_substitute (FcPattern *pattern,
|
|
+ gpointer data)
|
|
+{
|
|
+ FcPatternDel (pattern, FC_HINTING);
|
|
+ FcPatternAddBool (pattern, FC_HINTING, 0);
|
|
+}
|
|
+
|
|
+static PangoFontMap *
|
|
+get_fontmap (void)
|
|
+{
|
|
+ static PangoFontMap *fontmap = NULL;
|
|
+
|
|
+ if (!fontmap) {
|
|
+ fontmap = pango_ft2_font_map_new ();
|
|
+ pango_ft2_font_map_set_resolution ((PangoFT2FontMap *)fontmap, 72., 72.);
|
|
+ pango_ft2_font_map_set_default_substitute ((PangoFT2FontMap *)fontmap, default_substitute, NULL, NULL);
|
|
+ }
|
|
+
|
|
+ return fontmap;
|
|
+}
|
|
+
|
|
+static PangoContext *
|
|
+get_context (void)
|
|
+{
|
|
+ return pango_ft2_font_map_create_context ((PangoFT2FontMap *) get_fontmap ());
|
|
+}
|
|
+
|
|
+// 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);
|
|
+
|
|
+#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 PangoLanguage *GetPangoLanguage(nsIAtom *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);
|
|
+
|
|
+nsFontMetricsPSPango::nsFontMetricsPSPango()
|
|
+{
|
|
+ if (!gPangoFontLog)
|
|
+ gPangoFontLog = PR_NewLogModule("PangoFont");
|
|
+
|
|
+ gNumInstances++;
|
|
+
|
|
+ mPangoFontDesc = nsnull;
|
|
+ mPangoContext = nsnull;
|
|
+ mLTRPangoContext = nsnull;
|
|
+ mRTLPangoContext = nsnull;
|
|
+ mPangoAttrList = nsnull;
|
|
+ mIsRTL = PR_FALSE;
|
|
+ mPangoSpaceWidth = 0;
|
|
+
|
|
+ static PRBool initialized = PR_FALSE;
|
|
+ if (initialized)
|
|
+ return;
|
|
+
|
|
+ // Initialized the custom decoders
|
|
+ if (!mozilla_ps_decoders_init(get_fontmap ()))
|
|
+ initialized = PR_TRUE;
|
|
+}
|
|
+
|
|
+nsFontMetricsPSPango::~nsFontMetricsPSPango()
|
|
+{
|
|
+ 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(nsFontMetricsPSPango, nsIFontMetrics)
|
|
+
|
|
+// nsIFontMetrics impl
|
|
+
|
|
+NS_IMETHODIMP
|
|
+nsFontMetricsPSPango::Init(const nsFont& aFont, nsIAtom* aLangGroup,
|
|
+ nsIDeviceContext *aContext)
|
|
+{
|
|
+ mFont = aFont;
|
|
+ mLangGroup = aLangGroup;
|
|
+
|
|
+ // Hang on to the device context
|
|
+ mDeviceContext = aContext;
|
|
+
|
|
+ mPointSize = NSTwipsToFloatPoints(mFont.size);
|
|
+
|
|
+ // enumerate over the font names passed in
|
|
+ mFont.EnumerateFamilies(nsFontMetricsPSPango::EnumFontCallback, this);
|
|
+
|
|
+ nsCOMPtr<nsIPref> prefService;
|
|
+ prefService = do_GetService(NS_PREF_CONTRACTID);
|
|
+ if (!prefService)
|
|
+ return NS_ERROR_FAILURE;
|
|
+
|
|
+ nsXPIDLCString value;
|
|
+ const char* langGroup;
|
|
+ mLangGroup->GetUTF8String(&langGroup);
|
|
+
|
|
+ // Set up the default font name if it's not set
|
|
+ if (!mGenericFont) {
|
|
+ nsCAutoString name("font.default.");
|
|
+ name.Append(langGroup);
|
|
+ prefService->CopyCharPref(name.get(), 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('.'));
|
|
+ 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: nsFontMetricsPSPango 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
|
|
+nsFontMetricsPSPango::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;
|
|
+ face = pango_fc_font_lock_face(fcfont);
|
|
+ if (!face)
|
|
+ return NS_ERROR_NOT_AVAILABLE;
|
|
+
|
|
+ TT_OS2 *os2;
|
|
+ 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
|
|
+ val = MOZ_FT_TRUNC(face->size->metrics.ascender);
|
|
+ mMaxAscent = NSToIntRound(val * f);
|
|
+
|
|
+ // mMaxDescent
|
|
+ val = -MOZ_FT_TRUNC(face->size->metrics.descender);
|
|
+ mMaxDescent = NSToIntRound(val * 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
|
|
+ val = MOZ_FT_TRUNC(face->size->metrics.max_advance);
|
|
+ mMaxAdvance = NSToIntRound(val * f);
|
|
+
|
|
+ // mPangoSpaceWidth
|
|
+ PangoLayout *layout = pango_layout_new(mPangoContext);
|
|
+ pango_layout_set_text(layout, " ", 1);
|
|
+ int pswidth, psheight;
|
|
+ pango_layout_get_size(layout, &pswidth, &psheight);
|
|
+ mPangoSpaceWidth = pswidth;
|
|
+ g_object_unref(layout);
|
|
+
|
|
+ // mSpaceWidth (width of a space)
|
|
+ nscoord tmpWidth;
|
|
+ GetWidth(" ", 1, tmpWidth);
|
|
+ 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);
|
|
+ mAveCharWidth = tmpWidth;
|
|
+
|
|
+ // mXHeight (height of an 'x' character)
|
|
+ if (pango_fc_font_has_char(fcfont, 'x')) {
|
|
+ PangoRectangle rect;
|
|
+ PangoGlyph glyph = pango_fc_font_get_glyph (fcfont, 'x');
|
|
+ pango_font_get_glyph_extents (PANGO_FONT (fcfont), glyph, &rect, NULL);
|
|
+ mXHeight = NSToIntRound(rect.height * f / PANGO_SCALE);
|
|
+ }
|
|
+ else {
|
|
+ // 56% of ascent, best guess for non-true type or asian fonts
|
|
+ mXHeight = nscoord(((float)mMaxAscent) * 0.56 * 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 *
|
|
+ MOZ_FT_TRUNC(face->size->metrics.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 * MOZ_FT_TRUNC(face->size->metrics.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;
|
|
+
|
|
+ pango_fc_font_unlock_face(fcfont);
|
|
+
|
|
+ /*
|
|
+ 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
|
|
+nsFontMetricsPSPango::Destroy()
|
|
+{
|
|
+ mDeviceContext = nsnull;
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+NS_IMETHODIMP
|
|
+nsFontMetricsPSPango::GetLangGroup(nsIAtom** aLangGroup)
|
|
+{
|
|
+ *aLangGroup = mLangGroup;
|
|
+ NS_IF_ADDREF(*aLangGroup);
|
|
+
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+NS_IMETHODIMP
|
|
+nsFontMetricsPSPango::GetFontHandle(nsFontHandle &aHandle)
|
|
+{
|
|
+ return NS_ERROR_NOT_IMPLEMENTED;
|
|
+}
|
|
+
|
|
+// nsIFontMetricsPango impl
|
|
+NS_IMETHODIMP
|
|
+nsFontMetricsPSPango::GetStringWidth(const char *String,nscoord &aWidth,nscoord aLength)
|
|
+{
|
|
+ return GetWidth (String, (PRUint32) aLength, aWidth);
|
|
+}
|
|
+
|
|
+NS_IMETHODIMP
|
|
+nsFontMetricsPSPango::GetStringWidth(const PRUnichar *aString,nscoord &aWidth,nscoord aLength)
|
|
+{
|
|
+ return GetWidth (aString, (PRUint32)aLength, aWidth);
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPSPango::GetWidth(const char* aString, PRUint32 aLength,
|
|
+ nscoord& aWidth)
|
|
+{
|
|
+ PangoLayout *layout = pango_layout_new(mPangoContext);
|
|
+
|
|
+ pango_layout_set_text(layout, aString, aLength);
|
|
+
|
|
+ if (mPangoSpaceWidth)
|
|
+ FixupSpaceWidths(layout, aString);
|
|
+
|
|
+ int width, height;
|
|
+
|
|
+ pango_layout_get_size(layout, &width, &height);
|
|
+
|
|
+ g_object_unref(layout);
|
|
+
|
|
+ float f;
|
|
+ f = mDeviceContext->DevUnitsToAppUnits();
|
|
+ aWidth = NSToCoordRound(width * f / PANGO_SCALE);
|
|
+
|
|
+ // printf("GetWidth (char *) %d\n", aWidth);
|
|
+
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPSPango::GetWidth(const PRUnichar* aString, PRUint32 aLength,
|
|
+ nscoord& aWidth)
|
|
+{
|
|
+ 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("nsFontMetricsPSPango::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));
|
|
+ FixupSpaceWidths(layout, text);
|
|
+ pango_layout_get_size(layout, &width, &height);
|
|
+
|
|
+ float f;
|
|
+ f = mDeviceContext->DevUnitsToAppUnits();
|
|
+ aWidth = NSToCoordRound(width * f / PANGO_SCALE);
|
|
+
|
|
+ // printf("GetWidth %d\n", aWidth);
|
|
+
|
|
+ loser:
|
|
+ g_free(text);
|
|
+ g_object_unref(layout);
|
|
+
|
|
+ return rv;
|
|
+}
|
|
+
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPSPango :: GetTextDimensions(const char* aString, PRUint32 aLength,
|
|
+ nsTextDimensions& aDimensions)
|
|
+{
|
|
+ nsresult rv = NS_OK;
|
|
+
|
|
+ PangoLayout *layout = pango_layout_new(mPangoContext);
|
|
+
|
|
+ pango_layout_set_text(layout, aString, aLength);
|
|
+ FixupSpaceWidths(layout,aString);
|
|
+
|
|
+ // 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 * P2T / PANGO_SCALE);
|
|
+ aDimensions.ascent = NSToCoordRound(PANGO_ASCENT(rect) * P2T / PANGO_SCALE);
|
|
+ aDimensions.descent = NSToCoordRound(PANGO_DESCENT(rect) * P2T / PANGO_SCALE);
|
|
+
|
|
+ // printf("GetTextDimensions %d %d %d\n", aDimensions.width,
|
|
+ //aDimensions.ascent, aDimensions.descent);
|
|
+
|
|
+ loser:
|
|
+ g_object_unref(layout);
|
|
+
|
|
+ return rv;
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPSPango::GetTextDimensions(const PRUnichar* aString,
|
|
+ PRUint32 aLength,
|
|
+ nsTextDimensions& aDimensions,
|
|
+ PRInt32* aFontID)
|
|
+{
|
|
+ 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("nsFontMetricsPSPango::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));
|
|
+ FixupSpaceWidths(layout, 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 * P2T / PANGO_SCALE);
|
|
+ aDimensions.ascent = NSToCoordRound(PANGO_ASCENT(rect) * P2T / PANGO_SCALE);
|
|
+ aDimensions.descent = NSToCoordRound(PANGO_DESCENT(rect) * P2T / PANGO_SCALE);
|
|
+
|
|
+ // printf("GetTextDimensions %d %d %d\n", aDimensions.width,
|
|
+ //aDimensions.ascent, aDimensions.descent);
|
|
+
|
|
+ loser:
|
|
+ g_free(text);
|
|
+ g_object_unref(layout);
|
|
+
|
|
+ return rv;
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPSPango::GetTextDimensions(const char* aString,
|
|
+ PRInt32 aLength,
|
|
+ PRInt32 aAvailWidth,
|
|
+ PRInt32* aBreaks,
|
|
+ PRInt32 aNumBreaks,
|
|
+ nsTextDimensions& aDimensions,
|
|
+ PRInt32& aNumCharsFit,
|
|
+ nsTextDimensions& aLastWordDimensions,
|
|
+ PRInt32* aFontID)
|
|
+{
|
|
+
|
|
+ return GetTextDimensionsInternal(aString, aLength, aAvailWidth, aBreaks,
|
|
+ aNumBreaks, aDimensions, aNumCharsFit,
|
|
+ aLastWordDimensions);
|
|
+
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPSPango::GetTextDimensions(const PRUnichar* aString,
|
|
+ PRInt32 aLength,
|
|
+ PRInt32 aAvailWidth,
|
|
+ PRInt32* aBreaks,
|
|
+ PRInt32 aNumBreaks,
|
|
+ nsTextDimensions& aDimensions,
|
|
+ PRInt32& aNumCharsFit,
|
|
+ nsTextDimensions& aLastWordDimensions,
|
|
+ PRInt32* aFontID)
|
|
+{
|
|
+ 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("nsFontMetricsPSPango::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);
|
|
+
|
|
+ // 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;
|
|
+}
|
|
+
|
|
+typedef struct _nsPSPangoRenderer nsPSPangoRenderer;
|
|
+typedef struct _nsPSPangoRendererClass nsPSPangoRendererClass;
|
|
+
|
|
+struct _nsPSPangoRenderer
|
|
+{
|
|
+ PangoRenderer parent_instance;
|
|
+ nsRenderingContextPS *psContext;
|
|
+ nsFontMetricsPSPango *psPangoFontMetrics;
|
|
+ float zoom;
|
|
+};
|
|
+
|
|
+struct _nsPSPangoRendererClass
|
|
+{
|
|
+ PangoRendererClass parent_class;
|
|
+};
|
|
+
|
|
+#define _PS_TYPE_PANGO_RENDERER (_ps_pango_renderer_get_type())
|
|
+#define _PS_PANGO_RENDERER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), _PS_TYPE_PANGO_RENDERER, _nsPSPangoRenderer))
|
|
+#define _PS_IS_PANGO_RENDERER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), _PS_TYPE_PANGO_RENDERER))
|
|
+#define _PS_PANGO_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), _PS_TYPE_PANGO_RENDERER, _nsPSPangoRendererClass))
|
|
+#define _PS_IS_PANGO_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), _PS_TYPE_PANGO_RENDERER))
|
|
+#define _PS_PANGO_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), _PS_TYPE_PANGO_RENDERER, _nsPSPangoRendererClass))
|
|
+
|
|
+G_DEFINE_TYPE (_nsPSPangoRenderer, _ps_pango_renderer, PANGO_TYPE_RENDERER)
|
|
+
|
|
+static PangoRenderer *
|
|
+get_renderer (void)
|
|
+{
|
|
+ static PangoRenderer *renderer = NULL;
|
|
+
|
|
+ if (!renderer)
|
|
+ renderer = (PangoRenderer *) g_object_new (_PS_TYPE_PANGO_RENDERER, NULL);
|
|
+
|
|
+ return renderer;
|
|
+}
|
|
+
|
|
+static void
|
|
+_ps_pango_renderer_draw_glyphs (PangoRenderer *renderer,
|
|
+ PangoFont *font,
|
|
+ PangoGlyphString *glyphs,
|
|
+ int x,
|
|
+ int y);
|
|
+
|
|
+static void
|
|
+_ps_pango_renderer_class_init (nsPSPangoRendererClass *klass)
|
|
+{
|
|
+ PangoRendererClass *renderer_class = PANGO_RENDERER_CLASS (klass);
|
|
+
|
|
+ renderer_class->draw_glyphs = _ps_pango_renderer_draw_glyphs;
|
|
+}
|
|
+
|
|
+static void
|
|
+_ps_pango_renderer_init (nsPSPangoRenderer *renderer)
|
|
+{
|
|
+}
|
|
+
|
|
+class nsPangoType1Generator : public nsPSFontGenerator {
|
|
+public:
|
|
+ nsPangoType1Generator();
|
|
+ ~nsPangoType1Generator();
|
|
+ nsresult Init(PangoFont *aFont);
|
|
+ void GeneratePSFont(FILE* aFile);
|
|
+
|
|
+protected:
|
|
+ PangoFont *mFont;
|
|
+};
|
|
+
|
|
+nsPangoType1Generator::nsPangoType1Generator()
|
|
+{
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsPangoType1Generator::Init(PangoFont *aFont)
|
|
+{
|
|
+ NS_ENSURE_TRUE(aFont, NS_ERROR_FAILURE);
|
|
+ mFont = aFont;
|
|
+ g_object_ref (mFont);
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+nsPangoType1Generator::~nsPangoType1Generator()
|
|
+{
|
|
+ g_object_unref (mFont);
|
|
+ mFont = nsnull;
|
|
+}
|
|
+
|
|
+void nsPangoType1Generator::GeneratePSFont(FILE* aFile)
|
|
+{
|
|
+ FT_Face face = pango_fc_font_lock_face ((PangoFcFont *) mFont);
|
|
+
|
|
+ if (face == nsnull)
|
|
+ return;
|
|
+
|
|
+ int wmode = 0;
|
|
+ if (mGlyphSubset->Count())
|
|
+ FT2SubsetToType1FontSet(face, mGlyphSubset, wmode, aFile);
|
|
+
|
|
+ pango_fc_font_unlock_face ((PangoFcFont *) mFont);
|
|
+}
|
|
+
|
|
+typedef struct
|
|
+{
|
|
+ nsCString *FontNameBase;
|
|
+ nsCStringKey *key;
|
|
+ int font_size;
|
|
+} PSPangoFontData;
|
|
+
|
|
+static void
|
|
+ps_pango_font_data_destroy (PSPangoFontData *data)
|
|
+{
|
|
+ delete data->key;
|
|
+ delete data->FontNameBase;
|
|
+ g_free (data);
|
|
+}
|
|
+
|
|
+static void
|
|
+flattenName(nsCString& aString)
|
|
+{
|
|
+ nsCString::iterator start, end;
|
|
+ aString.BeginWriting(start);
|
|
+ aString.EndWriting(end);
|
|
+ while(start != end) {
|
|
+ if (*start == ' ')
|
|
+ *start= '_';
|
|
+ else if (*start == '(')
|
|
+ *start = '_';
|
|
+ else if (*start == ')')
|
|
+ *start = '_';
|
|
+ ++start;
|
|
+ }
|
|
+}
|
|
+
|
|
+static void
|
|
+_ps_pango_renderer_draw_glyphs (PangoRenderer *renderer,
|
|
+ PangoFont *font,
|
|
+ PangoGlyphString *glyphs,
|
|
+ int x,
|
|
+ int y)
|
|
+{
|
|
+ if (!glyphs->num_glyphs)
|
|
+ return;
|
|
+
|
|
+ static GQuark data_quark = 0;
|
|
+ if (!data_quark)
|
|
+ data_quark = g_quark_from_static_string ("ps-pango-font-data");
|
|
+
|
|
+ PSPangoFontData *data;
|
|
+ if (!(data = (PSPangoFontData *) g_object_get_qdata (G_OBJECT (font), data_quark)))
|
|
+ {
|
|
+ data = g_new (PSPangoFontData, 1);
|
|
+
|
|
+ FT_Face face = pango_fc_font_lock_face ((PangoFcFont *) font);
|
|
+ if (face == nsnull)
|
|
+ return;
|
|
+ int wmode = 0;
|
|
+ data->FontNameBase = new nsCString ();
|
|
+ if (NS_FAILED(FT2ToType1FontName(face, wmode, *data->FontNameBase))) {
|
|
+ g_free (data);
|
|
+ pango_fc_font_unlock_face ((PangoFcFont *) font);
|
|
+ return;
|
|
+ }
|
|
+ pango_fc_font_unlock_face ((PangoFcFont *) font);
|
|
+
|
|
+ PangoFontDescription *desc = pango_font_describe (font);
|
|
+ data->font_size = pango_font_description_get_size (desc);
|
|
+ pango_font_description_free (desc);
|
|
+
|
|
+ data->key = new nsCStringKey (*data->FontNameBase);
|
|
+
|
|
+ g_object_set_qdata_full (G_OBJECT (font), data_quark, data, (GDestroyNotify) ps_pango_font_data_destroy);
|
|
+ }
|
|
+
|
|
+ nsPSPangoRenderer *ps_renderer = (nsPSPangoRenderer *)renderer;
|
|
+ nsRenderingContextPS *aContext = ps_renderer->psContext;
|
|
+ nsFontMetricsPSPango *metrics = ps_renderer->psPangoFontMetrics;
|
|
+ nsDeviceContextPS* dc = NS_REINTERPRET_CAST (nsDeviceContextPS*, metrics->GetDeviceContext());
|
|
+ nsPostScriptObj* psObj = aContext->GetPostScriptObj();
|
|
+ nsHashtable *psFGList = dc->GetPSFontGeneratorList();
|
|
+ g_return_if_fail (psFGList);
|
|
+ nsPSFontGenerator* psFontGen = (nsPSFontGenerator*) psFGList->Get(data->key);
|
|
+ if (!psFontGen) {
|
|
+ nsresult rv;
|
|
+ psFontGen = new nsPangoType1Generator;
|
|
+ g_return_if_fail (psFontGen);
|
|
+ rv = ((nsPangoType1Generator*)psFontGen)->Init(font);
|
|
+ if (NS_FAILED(rv)) {
|
|
+ delete psFontGen;
|
|
+ return;
|
|
+ }
|
|
+ psFGList->Put(data->key, (void *) psFontGen);
|
|
+ }
|
|
+ nscoord font_size = NSToCoordRound (ps_renderer->zoom * data->font_size / PANGO_SCALE);
|
|
+
|
|
+ g_return_if_fail (aContext);
|
|
+ g_return_if_fail (psObj);
|
|
+
|
|
+ nscoord aX = NSToCoordRound(ps_renderer->zoom * x / PANGO_SCALE);
|
|
+ nscoord aY = NSToCoordRound(ps_renderer->zoom * y / PANGO_SCALE);
|
|
+ psObj->moveto(aX, aY);
|
|
+
|
|
+ PRInt32 currSubFont, prevSubFont = -1;
|
|
+ PRUint32 i;
|
|
+ PangoGlyphString gl;
|
|
+
|
|
+ gl.glyphs = glyphs->glyphs;
|
|
+ gl.num_glyphs = 0;
|
|
+ for (i = 0; i < glyphs->num_glyphs; ++i) {
|
|
+ currSubFont = psFontGen->AddToGlyphSubset(glyphs->glyphs[i].glyph >= 0x00ffffff ? 0 : glyphs->glyphs[i].glyph);
|
|
+ if (prevSubFont != currSubFont) {
|
|
+ if (prevSubFont != -1)
|
|
+ psObj->show(&gl, ps_renderer->zoom, psFontGen, prevSubFont);
|
|
+
|
|
+
|
|
+ psObj->setfont(*data->FontNameBase, (PRUint32) font_size, currSubFont);
|
|
+ prevSubFont = currSubFont;
|
|
+ gl.glyphs = glyphs->glyphs + i;
|
|
+ gl.num_glyphs = 0;
|
|
+ }
|
|
+
|
|
+ gl.num_glyphs++;
|
|
+ }
|
|
+
|
|
+ if (prevSubFont != -1)
|
|
+ psObj->show(&gl, ps_renderer->zoom, psFontGen, prevSubFont);
|
|
+}
|
|
+
|
|
+static void
|
|
+draw_layout_line (int x, int y, PangoLayoutLine *line, nsFontMetricsPSPango *aPSPangoFontMetrics, nsRenderingContextPS *aContext)
|
|
+{
|
|
+ PangoRenderer *renderer = get_renderer ();
|
|
+ nsPSPangoRenderer *ps_renderer = (nsPSPangoRenderer *)renderer;
|
|
+ ps_renderer->psContext = aContext;
|
|
+ ps_renderer->psPangoFontMetrics = aPSPangoFontMetrics;
|
|
+ nsDeviceContextPS* dc = NS_REINTERPRET_CAST (nsDeviceContextPS*, aPSPangoFontMetrics->GetDeviceContext());
|
|
+ ps_renderer->zoom = dc->DevUnitsToAppUnits();
|
|
+
|
|
+ pango_renderer_draw_layout_line (renderer, line,
|
|
+ NSToCoordRound (x * PANGO_SCALE / ps_renderer->zoom),
|
|
+ NSToCoordRound (y * PANGO_SCALE / ps_renderer->zoom));
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPSPango::DrawString(const char *aString, PRUint32 aLength,
|
|
+ nscoord aX, nscoord aY,
|
|
+ const nscoord* aSpacing,
|
|
+ nsRenderingContextPS *aContext)
|
|
+{
|
|
+ PangoLayout *layout = pango_layout_new(mPangoContext);
|
|
+
|
|
+ pango_layout_set_text(layout, aString, aLength);
|
|
+ FixupSpaceWidths(layout, aString);
|
|
+
|
|
+ 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);
|
|
+
|
|
+ if (aSpacing && *aSpacing) {
|
|
+ DrawStringSlowly(aString, NULL, aLength, x, y, line, aSpacing, aContext);
|
|
+ }
|
|
+ else {
|
|
+ draw_layout_line (x, y, line, this, aContext);
|
|
+ }
|
|
+
|
|
+ g_object_unref(layout);
|
|
+
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPSPango::DrawString(const PRUnichar* aString, PRUint32 aLength,
|
|
+ nscoord aX, nscoord aY,
|
|
+ PRInt32 aFontID,
|
|
+ const nscoord* aSpacing,
|
|
+ nsRenderingContextPS *aContext)
|
|
+{
|
|
+ nsresult rv = NS_OK;
|
|
+ int x = aX;
|
|
+ int y = aY;
|
|
+
|
|
+ PangoLayout *layout = pango_layout_new(mPangoContext);
|
|
+
|
|
+ gchar *text = g_utf16_to_utf8(aString, aLength,
|
|
+ NULL, NULL, NULL);
|
|
+ if (!text) {
|
|
+#ifdef DEBUG
|
|
+ NS_WARNING("nsFontMetricsPSPango::DrawString invalid unicode to follow");
|
|
+ DUMP_PRUNICHAR(aString, aLength)
|
|
+#endif
|
|
+ rv = NS_ERROR_FAILURE;
|
|
+ goto loser;
|
|
+ }
|
|
+
|
|
+ pango_layout_set_text(layout, text, strlen(text));
|
|
+ FixupSpaceWidths(layout, 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, x, y, line, aSpacing, aContext);
|
|
+ }
|
|
+ else {
|
|
+ draw_layout_line (x, y, line, this, aContext);
|
|
+ }
|
|
+
|
|
+ loser:
|
|
+
|
|
+ g_free(text);
|
|
+ g_object_unref(layout);
|
|
+
|
|
+ return rv;
|
|
+}
|
|
+
|
|
+#ifdef MOZ_MATHML
|
|
+nsresult
|
|
+nsFontMetricsPSPango::GetBoundingMetrics(const char *aString, PRUint32 aLength,
|
|
+ nsBoundingMetrics &aBoundingMetrics)
|
|
+{
|
|
+ printf("GetBoundingMetrics (char *)\n");
|
|
+ return NS_ERROR_FAILURE;
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPSPango::GetBoundingMetrics(const PRUnichar *aString,
|
|
+ PRUint32 aLength,
|
|
+ nsBoundingMetrics &aBoundingMetrics,
|
|
+ PRInt32 *aFontID)
|
|
+{
|
|
+ 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("nsFontMetricsPSPango::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, -1);
|
|
+ FixupSpaceWidths(layout, text);
|
|
+
|
|
+ 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 and logical extents
|
|
+ PangoRectangle ink, logical;
|
|
+ pango_layout_line_get_extents(line, &ink, &logical);
|
|
+
|
|
+ float P2T;
|
|
+ P2T = mDeviceContext->DevUnitsToAppUnits();
|
|
+
|
|
+ aBoundingMetrics.leftBearing = NSToCoordRound(PANGO_LBEARING(ink) * P2T / PANGO_SCALE);
|
|
+ aBoundingMetrics.rightBearing = NSToCoordRound(PANGO_RBEARING(ink) * P2T / PANGO_SCALE);
|
|
+ aBoundingMetrics.ascent = NSToCoordRound(PANGO_ASCENT(ink) * P2T / PANGO_SCALE);
|
|
+ aBoundingMetrics.descent = NSToCoordRound(PANGO_DESCENT(ink) * P2T / PANGO_SCALE);
|
|
+ aBoundingMetrics.width = NSToCoordRound(logical.width * P2T / PANGO_SCALE);
|
|
+
|
|
+ loser:
|
|
+ g_free(text);
|
|
+ g_object_unref(layout);
|
|
+
|
|
+ return rv;
|
|
+}
|
|
+
|
|
+#endif /* MOZ_MATHML */
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPSPango::SetRightToLeftText(PRBool aIsRTL)
|
|
+{
|
|
+ if (aIsRTL) {
|
|
+ if (!mRTLPangoContext) {
|
|
+ mRTLPangoContext = get_context();
|
|
+ pango_context_set_base_dir(mRTLPangoContext, PANGO_DIRECTION_RTL);
|
|
+
|
|
+ pango_context_set_language(mRTLPangoContext, GetPangoLanguage(mLangGroup));
|
|
+ pango_context_set_font_description(mRTLPangoContext, mPangoFontDesc);
|
|
+ }
|
|
+ mPangoContext = mRTLPangoContext;
|
|
+ }
|
|
+ else {
|
|
+ mPangoContext = mLTRPangoContext;
|
|
+ }
|
|
+
|
|
+ mIsRTL = aIsRTL;
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPSPango::GetClusterInfo(const PRUnichar *aText,
|
|
+ PRUint32 aLength,
|
|
+ PRUint8 *aClusterStarts)
|
|
+{
|
|
+ nsresult rv = NS_OK;
|
|
+ PangoLogAttr *attrs = NULL;
|
|
+ gint n_attrs = 0;
|
|
+ PangoLayout *layout = pango_layout_new(mPangoContext);
|
|
+
|
|
+ // Convert the incoming UTF-16 to UTF-8
|
|
+ gchar *text = g_utf16_to_utf8(aText, aLength, NULL, NULL, NULL);
|
|
+
|
|
+ if (!text) {
|
|
+#ifdef DEBUG
|
|
+ NS_WARNING("nsFontMetricsPSPango::GetWidth invalid unicode to follow");
|
|
+ DUMP_PRUNICHAR(aText, aLength)
|
|
+#endif
|
|
+ rv = NS_ERROR_FAILURE;
|
|
+ goto loser;
|
|
+ }
|
|
+
|
|
+ // Set up the pango layout
|
|
+ pango_layout_set_text(layout, text, strlen(text));
|
|
+ FixupSpaceWidths(layout, text);
|
|
+
|
|
+ // Convert back to UTF-16 while filling in the cluster info
|
|
+ // structure.
|
|
+ pango_layout_get_log_attrs(layout, &attrs, &n_attrs);
|
|
+
|
|
+ for (PRUint32 pos = 0; pos < aLength; pos++) {
|
|
+ if (IS_HIGH_SURROGATE(aText[pos])) {
|
|
+ aClusterStarts[pos] = 1;
|
|
+ pos++;
|
|
+ }
|
|
+ else {
|
|
+ aClusterStarts[pos] = attrs[pos].is_cursor_position;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ loser:
|
|
+ if (attrs)
|
|
+ g_free(attrs);
|
|
+ if (text)
|
|
+ g_free(text);
|
|
+ if (layout)
|
|
+ g_object_unref(layout);
|
|
+
|
|
+ return rv;
|
|
+}
|
|
+
|
|
+PRInt32
|
|
+nsFontMetricsPSPango::GetPosition(const PRUnichar *aText, PRUint32 aLength,
|
|
+ nsPoint aPt)
|
|
+{
|
|
+ int trailing = 0;
|
|
+ int inx = 0;
|
|
+ const gchar *curChar;
|
|
+ PRInt32 retval = 0;
|
|
+
|
|
+ float f = mDeviceContext->AppUnitsToDevUnits();
|
|
+
|
|
+ PangoLayout *layout = pango_layout_new(mPangoContext);
|
|
+ PRUint32 localX = (PRUint32)(aPt.x * PANGO_SCALE * f);
|
|
+ PRUint32 localY = (PRUint32)(aPt.y * PANGO_SCALE * f);
|
|
+
|
|
+ // Convert the incoming UTF-16 to UTF-8
|
|
+ gchar *text = g_utf16_to_utf8(aText, aLength, NULL, NULL, NULL);
|
|
+
|
|
+ if (!text) {
|
|
+#ifdef DEBUG
|
|
+ NS_WARNING("nsFontMetricsPSPango::GetWidth invalid unicode to follow");
|
|
+ DUMP_PRUNICHAR(aText, aLength)
|
|
+#endif
|
|
+ retval = -1;
|
|
+ goto loser;
|
|
+ }
|
|
+
|
|
+ // Set up the pango layout
|
|
+ pango_layout_set_text(layout, text, strlen(text));
|
|
+ FixupSpaceWidths(layout, text);
|
|
+
|
|
+ pango_layout_xy_to_index(layout, localX, localY,
|
|
+ &inx, &trailing);
|
|
+
|
|
+ // Convert the index back to the utf-16 index
|
|
+ curChar = text;
|
|
+
|
|
+ for (PRUint32 curOffset=0; curOffset < aLength;
|
|
+ curOffset++, curChar = g_utf8_find_next_char(curChar, NULL)) {
|
|
+
|
|
+ // Check for a match before checking for a surrogate pair
|
|
+ if (curChar - text == inx) {
|
|
+ retval = curOffset;
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ if (IS_HIGH_SURROGATE(aText[curOffset]))
|
|
+ curOffset++;
|
|
+ }
|
|
+
|
|
+ // If there was a trailing result, advance the index pointer the
|
|
+ // number of characters equal to the trailing result.
|
|
+ while (trailing) {
|
|
+ retval++;
|
|
+ // Yes, this can make aInx > length to indicate the end of the
|
|
+ // string.
|
|
+ if (retval < (PRInt32)aLength && IS_HIGH_SURROGATE(aText[retval]))
|
|
+ retval++;
|
|
+ trailing--;
|
|
+ }
|
|
+
|
|
+ loser:
|
|
+ if (text)
|
|
+ g_free(text);
|
|
+ if (layout)
|
|
+ g_object_unref(layout);
|
|
+
|
|
+ return retval;
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPSPango::GetRangeWidth(const PRUnichar *aText,
|
|
+ PRUint32 aLength,
|
|
+ PRUint32 aStart,
|
|
+ PRUint32 aEnd,
|
|
+ PRUint32 &aWidth)
|
|
+{
|
|
+ nsresult rv = NS_OK;
|
|
+ PRUint32 utf8Start = 0;
|
|
+ PRUint32 utf8End = 0;
|
|
+
|
|
+ aWidth = 0;
|
|
+
|
|
+ // Convert the incoming UTF-16 to UTF-8
|
|
+ gchar *text = g_utf16_to_utf8(aText, aLength, NULL, NULL, NULL);
|
|
+ gchar *curChar = text;
|
|
+
|
|
+ if (!text) {
|
|
+#ifdef DEBUG
|
|
+ NS_WARNING("nsFontMetricsPSPango::GetWidth invalid unicode to follow");
|
|
+ DUMP_PRUNICHAR(aText, aLength)
|
|
+#endif
|
|
+ rv = NS_ERROR_FAILURE;
|
|
+ goto loser;
|
|
+ }
|
|
+
|
|
+ // Convert the utf16 offsets into utf8 offsets
|
|
+ for (PRUint32 curOffset = 0; curOffset < aLength;
|
|
+ curOffset++, curChar = g_utf8_find_next_char(curChar, NULL)) {
|
|
+
|
|
+ if (curOffset == aStart)
|
|
+ utf8Start = curChar - text;
|
|
+
|
|
+ if (curOffset == aEnd)
|
|
+ utf8End = curChar - text;
|
|
+
|
|
+ if (IS_HIGH_SURROGATE(aText[curOffset]))
|
|
+ curOffset++;
|
|
+ }
|
|
+
|
|
+ // Special case where the end index is the same as the length
|
|
+ if (aLength == aEnd)
|
|
+ utf8End = strlen(text);
|
|
+
|
|
+ rv = GetRangeWidth(text, strlen(text), utf8Start, utf8End, aWidth);
|
|
+
|
|
+ loser:
|
|
+ if (text)
|
|
+ g_free(text);
|
|
+
|
|
+ return rv;
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPSPango::GetRangeWidth(const char *aText,
|
|
+ PRUint32 aLength,
|
|
+ PRUint32 aStart,
|
|
+ PRUint32 aEnd,
|
|
+ PRUint32 &aWidth)
|
|
+{
|
|
+ nsresult rv = NS_OK;
|
|
+ int *ranges = NULL;
|
|
+ int n_ranges = 0;
|
|
+ float f;
|
|
+
|
|
+ aWidth = 0;
|
|
+
|
|
+ PangoLayout *layout = pango_layout_new(mPangoContext);
|
|
+
|
|
+ if (!aText) {
|
|
+ rv = NS_ERROR_FAILURE;
|
|
+ goto loser;
|
|
+ }
|
|
+
|
|
+ pango_layout_set_text(layout, aText, aLength);
|
|
+ FixupSpaceWidths(layout, aText);
|
|
+
|
|
+ PangoLayoutLine *line;
|
|
+ if (pango_layout_get_line_count(layout) != 1) {
|
|
+ printf("Warning: more than one line!\n");
|
|
+ }
|
|
+ line = pango_layout_get_line(layout, 0);
|
|
+
|
|
+ pango_layout_line_get_x_ranges(line, aStart, aEnd, &ranges, &n_ranges);
|
|
+
|
|
+ aWidth = (ranges[((n_ranges - 1) * 2) + 1] - ranges[0]);
|
|
+
|
|
+ f = mDeviceContext-> DevUnitsToAppUnits();
|
|
+ aWidth = nscoord(aWidth * f / PANGO_SCALE);
|
|
+
|
|
+ loser:
|
|
+ if (ranges)
|
|
+ g_free(ranges);
|
|
+ if (layout)
|
|
+ g_object_unref(layout);
|
|
+
|
|
+ return rv;
|
|
+}
|
|
+
|
|
+PRUint32
|
|
+nsFontMetricsPSPango::GetHints(void)
|
|
+{
|
|
+ return (NS_RENDERING_HINT_BIDI_REORDERING |
|
|
+ NS_RENDERING_HINT_ARABIC_SHAPING |
|
|
+ NS_RENDERING_HINT_FAST_MEASURE |
|
|
+ NS_RENDERING_HINT_REORDER_SPACED_TEXT |
|
|
+ NS_RENDERING_HINT_TEXT_CLUSTERS);
|
|
+}
|
|
+
|
|
+/* static */
|
|
+nsresult
|
|
+nsFontMetricsPSPango::FamilyExists(nsIDeviceContext *aDevice,
|
|
+ const nsString &aName)
|
|
+{
|
|
+ // fontconfig family name is always in UTF-8
|
|
+ NS_ConvertUTF16toUTF8 name(aName);
|
|
+
|
|
+ nsresult rv = NS_ERROR_FAILURE;
|
|
+ PangoContext *context = get_context();
|
|
+ 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
|
|
+nsFontMetricsPSPango::RealizeFont(void)
|
|
+{
|
|
+ nsCString familyList;
|
|
+ // Create and fill out the font description.
|
|
+ mPangoFontDesc = pango_font_description_new();
|
|
+
|
|
+ // Add CSS names - walk the list of fonts, adding the generic as
|
|
+ // the last font
|
|
+ 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);
|
|
+ familyList.Append(familyName->get());
|
|
+ familyList.Append(',');
|
|
+ }
|
|
+
|
|
+ // 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();
|
|
+ name += ".";
|
|
+
|
|
+ nsString langGroup;
|
|
+ mLangGroup->ToString(langGroup);
|
|
+
|
|
+ name.AppendWithConversion(langGroup);
|
|
+
|
|
+ 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) {
|
|
+ nsCString tmpstr;
|
|
+ tmpstr.Append(value);
|
|
+
|
|
+ familyList.Append(tmpstr);
|
|
+ familyList.Append(',');
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+
|
|
+ // Add the generic if there is one.
|
|
+ if (mGenericFont && !mFont.systemFont) {
|
|
+ familyList.Append(mGenericFont->get());
|
|
+ familyList.Append(',');
|
|
+ }
|
|
+
|
|
+ // Set the family
|
|
+ pango_font_description_set_family(mPangoFontDesc,
|
|
+ familyList.get());
|
|
+
|
|
+ // Set the point size
|
|
+ pango_font_description_set_size(mPangoFontDesc,
|
|
+ (gint)(mPointSize * PANGO_SCALE));
|
|
+
|
|
+ // Set the style
|
|
+ pango_font_description_set_style(mPangoFontDesc,
|
|
+ CalculateStyle(mFont.style));
|
|
+
|
|
+ // Set the weight
|
|
+ pango_font_description_set_weight(mPangoFontDesc,
|
|
+ CalculateWeight(mFont.weight));
|
|
+
|
|
+ // Now that we have the font description set up, create the
|
|
+ // context.
|
|
+ mLTRPangoContext = get_context();
|
|
+ mPangoContext = mLTRPangoContext;
|
|
+
|
|
+ // Make sure to set the base direction to LTR - if layout needs to
|
|
+ // render RTL text it will use ::SetRightToLeftText()
|
|
+ pango_context_set_base_dir(mPangoContext, PANGO_DIRECTION_LTR);
|
|
+
|
|
+ // Set the pango language now that we have a context
|
|
+ pango_context_set_language(mPangoContext, GetPangoLanguage(mLangGroup));
|
|
+
|
|
+ // And attach the font description to this context
|
|
+ pango_context_set_font_description(mPangoContext, mPangoFontDesc);
|
|
+
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+/* static */
|
|
+PRBool
|
|
+nsFontMetricsPSPango::EnumFontCallback(const nsString &aFamily,
|
|
+ PRBool aIsGeneric, void *aData)
|
|
+{
|
|
+ NS_ConvertUTF16toUTF8 name(aFamily);
|
|
+
|
|
+ // The newest fontconfig does the full Unicode case folding so that
|
|
+ // we're being lazy here by calling |ToLowerCase| after converting
|
|
+ // to UTF-8 assuming that in virtually all cases, we just have to
|
|
+ // fold [A-Z]. (bug 223653).
|
|
+ ToLowerCase(name);
|
|
+ nsFontMetricsPSPango *metrics = (nsFontMetricsPSPango *)aData;
|
|
+ metrics->mFontList.AppendCString(name);
|
|
+ metrics->mFontIsGeneric.AppendElement((void *)aIsGeneric);
|
|
+ if (aIsGeneric) {
|
|
+ metrics->mGenericFont =
|
|
+ metrics->mFontList.CStringAt(metrics->mFontList.Count() - 1);
|
|
+ return PR_FALSE; // stop processing
|
|
+ }
|
|
+
|
|
+ return PR_TRUE; // keep processing
|
|
+}
|
|
+
|
|
+/*
|
|
+ * This is only used when there's per-character spacing happening.
|
|
+ * Well, really it can be either line or character spacing but it's
|
|
+ * just turtles all the way down!
|
|
+ */
|
|
+
|
|
+void
|
|
+nsFontMetricsPSPango::DrawStringSlowly(const gchar *aText,
|
|
+ const PRUnichar *aOrigString,
|
|
+ PRUint32 aLength,
|
|
+ gint aX, gint aY,
|
|
+ PangoLayoutLine *aLine,
|
|
+ const nscoord *aSpacing,
|
|
+ nsRenderingContextPS *aContext)
|
|
+{
|
|
+ float app2dev;
|
|
+ app2dev = mDeviceContext->AppUnitsToDevUnits();
|
|
+ gint offset = 0;
|
|
+
|
|
+ /*
|
|
+ * We walk the list of glyphs returned in each layout run,
|
|
+ * matching up the glyphs with the characters in the source text.
|
|
+ * We use the aSpacing argument to figure out where to place those
|
|
+ * glyphs. It's important to note that since the string we're
|
|
+ * working with is in UTF-8 while the spacing argument assumes
|
|
+ * that offset will be part of the UTF-16 string. Logical
|
|
+ * attributes in pango are in byte offsets in the UTF-8 string, so
|
|
+ * we need to store the offsets based on the UTF-8 string.
|
|
+ */
|
|
+ nscoord *utf8spacing = new nscoord[strlen(aText)];
|
|
+
|
|
+ if (aOrigString) {
|
|
+ const gchar *curChar = aText;
|
|
+ bzero(utf8spacing, sizeof(nscoord) * strlen(aText));
|
|
+
|
|
+ // Covert the utf16 spacing offsets to utf8 spacing offsets
|
|
+ for (PRUint32 curOffset=0; curOffset < aLength;
|
|
+ curOffset++, curChar = g_utf8_find_next_char(curChar, NULL)) {
|
|
+ utf8spacing[curChar - aText] = aSpacing[curOffset];
|
|
+
|
|
+ if (IS_HIGH_SURROGATE(aOrigString[curOffset]))
|
|
+ curOffset++;
|
|
+ }
|
|
+ }
|
|
+ else {
|
|
+ memcpy(utf8spacing, aSpacing, (sizeof(nscoord *) * aLength));
|
|
+ }
|
|
+
|
|
+ gint curRun = 0;
|
|
+
|
|
+ for (GSList *tmpList = aLine->runs; tmpList && tmpList->data;
|
|
+ tmpList = tmpList->next, curRun++) {
|
|
+ PangoLayoutRun *layoutRun = (PangoLayoutRun *)tmpList->data;
|
|
+ gint tmpOffset = 0;
|
|
+
|
|
+ /* printf(" Rendering run %d: \"%s\"\n", curRun,
|
|
+ &aText[layoutRun->item->offset]); */
|
|
+
|
|
+ for (gint i=0; i < layoutRun->glyphs->num_glyphs; i++) {
|
|
+ /* printf("glyph %d offset %d orig width %d new width %d\n", i,
|
|
+ * layoutRun->glyphs->log_clusters[i] + layoutRun->item->offset,
|
|
+ * layoutRun->glyphs->glyphs[i].geometry.width,
|
|
+ * (gint)(utf8spacing[layoutRun->glyphs->log_clusters[i] + layoutRun->item->offset] * app2dev * PANGO_SCALE));
|
|
+ */
|
|
+ gint thisOffset = (gint)(utf8spacing[layoutRun->glyphs->log_clusters[i] + layoutRun->item->offset]
|
|
+ * app2dev * PANGO_SCALE);
|
|
+ layoutRun->glyphs->glyphs[i].geometry.width = thisOffset;
|
|
+ tmpOffset += thisOffset;
|
|
+ }
|
|
+
|
|
+ /* printf(" rendering at X coord %d\n", aX + offset); */
|
|
+ offset += tmpOffset;
|
|
+ }
|
|
+
|
|
+ draw_layout_line (aX, aY, aLine, this, aContext);
|
|
+
|
|
+ delete[] utf8spacing;
|
|
+}
|
|
+
|
|
+nsresult
|
|
+nsFontMetricsPSPango::GetTextDimensionsInternal(const gchar* aString,
|
|
+ PRInt32 aLength,
|
|
+ PRInt32 aAvailWidth,
|
|
+ PRInt32* aBreaks,
|
|
+ PRInt32 aNumBreaks,
|
|
+ nsTextDimensions& aDimensions,
|
|
+ PRInt32& aNumCharsFit,
|
|
+ nsTextDimensions& aLastWordDimensions)
|
|
+{
|
|
+ NS_PRECONDITION(aBreaks[aNumBreaks - 1] == aLength, "invalid break array");
|
|
+
|
|
+ // If we need to back up this state represents the last place
|
|
+ // we could break. We can use this to avoid remeasuring text
|
|
+ PRInt32 prevBreakState_BreakIndex = -1; // not known
|
|
+ // (hasn't been computed)
|
|
+ nscoord prevBreakState_Width = 0; // accumulated width to this point
|
|
+
|
|
+ // Initialize OUT parameters
|
|
+ GetMaxAscent(aLastWordDimensions.ascent);
|
|
+ GetMaxDescent(aLastWordDimensions.descent);
|
|
+ aLastWordDimensions.width = -1;
|
|
+ aNumCharsFit = 0;
|
|
+
|
|
+ // Iterate each character in the string and determine which font to use
|
|
+ nscoord width = 0;
|
|
+ PRInt32 start = 0;
|
|
+ nscoord aveCharWidth;
|
|
+ GetAveCharWidth(aveCharWidth);
|
|
+
|
|
+ while (start < aLength) {
|
|
+ // Estimate how many characters will fit. Do that by
|
|
+ // diving the available space by the average character
|
|
+ // width. Make sure the estimated number of characters is
|
|
+ // at least 1
|
|
+ PRInt32 estimatedNumChars = 0;
|
|
+
|
|
+ if (aveCharWidth > 0)
|
|
+ estimatedNumChars = (aAvailWidth - width) / aveCharWidth;
|
|
+
|
|
+ if (estimatedNumChars < 1)
|
|
+ estimatedNumChars = 1;
|
|
+
|
|
+ // Find the nearest break offset
|
|
+ PRInt32 estimatedBreakOffset = start + estimatedNumChars;
|
|
+ PRInt32 breakIndex;
|
|
+ nscoord numChars;
|
|
+
|
|
+ // Find the nearest place to break that is less than or equal to
|
|
+ // the estimated break offset
|
|
+ if (aLength <= estimatedBreakOffset) {
|
|
+ // All the characters should fit
|
|
+ numChars = aLength - start;
|
|
+ breakIndex = aNumBreaks - 1;
|
|
+ }
|
|
+ else {
|
|
+ breakIndex = prevBreakState_BreakIndex;
|
|
+ while (((breakIndex + 1) < aNumBreaks) &&
|
|
+ (aBreaks[breakIndex + 1] <= estimatedBreakOffset)) {
|
|
+ ++breakIndex;
|
|
+ }
|
|
+
|
|
+ if (breakIndex == prevBreakState_BreakIndex) {
|
|
+ ++breakIndex; // make sure we advanced past the
|
|
+ // previous break index
|
|
+ }
|
|
+
|
|
+ numChars = aBreaks[breakIndex] - start;
|
|
+ }
|
|
+
|
|
+ // Measure the text
|
|
+ nscoord twWidth = 0;
|
|
+ if ((1 == numChars) && (aString[start] == ' '))
|
|
+ GetSpaceWidth(twWidth);
|
|
+ else if (numChars > 0)
|
|
+ GetWidth(&aString[start], numChars, twWidth);
|
|
+
|
|
+ // See if the text fits
|
|
+ PRBool textFits = (twWidth + width) <= aAvailWidth;
|
|
+
|
|
+ // If the text fits then update the width and the number of
|
|
+ // characters that fit
|
|
+ if (textFits) {
|
|
+ aNumCharsFit += numChars;
|
|
+ width += twWidth;
|
|
+ start += numChars;
|
|
+
|
|
+ // This is a good spot to back up to if we need to so remember
|
|
+ // this state
|
|
+ prevBreakState_BreakIndex = breakIndex;
|
|
+ prevBreakState_Width = width;
|
|
+ }
|
|
+ else {
|
|
+ // See if we can just back up to the previous saved
|
|
+ // state and not have to measure any text
|
|
+ if (prevBreakState_BreakIndex > 0) {
|
|
+ // If the previous break index is just before the
|
|
+ // current break index then we can use it
|
|
+ if (prevBreakState_BreakIndex == (breakIndex - 1)) {
|
|
+ aNumCharsFit = aBreaks[prevBreakState_BreakIndex];
|
|
+ width = prevBreakState_Width;
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ // We can't just revert to the previous break state
|
|
+ if (0 == breakIndex) {
|
|
+ // There's no place to back up to, so even though
|
|
+ // the text doesn't fit return it anyway
|
|
+ aNumCharsFit += numChars;
|
|
+ width += twWidth;
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ // Repeatedly back up until we get to where the text
|
|
+ // fits or we're all the way back to the first word
|
|
+ width += twWidth;
|
|
+ while ((breakIndex >= 1) && (width > aAvailWidth)) {
|
|
+ twWidth = 0;
|
|
+ start = aBreaks[breakIndex - 1];
|
|
+ numChars = aBreaks[breakIndex] - start;
|
|
+
|
|
+ if ((1 == numChars) && (aString[start] == ' '))
|
|
+ GetSpaceWidth(twWidth);
|
|
+ else if (numChars > 0)
|
|
+ GetWidth(&aString[start], numChars, twWidth);
|
|
+ width -= twWidth;
|
|
+ aNumCharsFit = start;
|
|
+ breakIndex--;
|
|
+ }
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ aDimensions.width = width;
|
|
+ GetMaxAscent(aDimensions.ascent);
|
|
+ GetMaxDescent(aDimensions.descent);
|
|
+
|
|
+ /* printf("aDimensions %d %d %d aLastWordDimensions %d %d %d aNumCharsFit %d\n",
|
|
+ aDimensions.width, aDimensions.ascent, aDimensions.descent,
|
|
+ aLastWordDimensions.width, aLastWordDimensions.ascent, aLastWordDimensions.descent,
|
|
+ aNumCharsFit); */
|
|
+
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+void
|
|
+nsFontMetricsPSPango::FixupSpaceWidths (PangoLayout *aLayout,
|
|
+ const char *aString)
|
|
+{
|
|
+ PangoLayoutLine *line = pango_layout_get_line(aLayout, 0);
|
|
+
|
|
+ gint curRun = 0;
|
|
+
|
|
+ for (GSList *tmpList = line->runs; tmpList && tmpList->data;
|
|
+ tmpList = tmpList->next, curRun++) {
|
|
+ PangoLayoutRun *layoutRun = (PangoLayoutRun *)tmpList->data;
|
|
+
|
|
+ for (gint i=0; i < layoutRun->glyphs->num_glyphs; i++) {
|
|
+ gint thisOffset = (gint)layoutRun->glyphs->log_clusters[i] + layoutRun->item->offset;
|
|
+ if (aString[thisOffset] == ' ')
|
|
+ layoutRun->glyphs->glyphs[i].geometry.width = mPangoSpaceWidth;
|
|
+ }
|
|
+ }
|
|
+}
|
|
+
|
|
+/* static */
|
|
+PangoLanguage *
|
|
+GetPangoLanguage(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 MozGtkLangGroup *langGroup;
|
|
+ langGroup = NS_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)
|
|
+ return pango_language_from_string(cname.get());
|
|
+ else if (langGroup->Lang)
|
|
+ return pango_language_from_string((char *) langGroup->Lang);
|
|
+
|
|
+ return pango_language_from_string("en");
|
|
+}
|
|
+
|
|
+/* static */
|
|
+void
|
|
+FreeGlobals(void)
|
|
+{
|
|
+}
|
|
+
|
|
+/* static */
|
|
+PangoStyle
|
|
+CalculateStyle(PRUint8 aStyle)
|
|
+{
|
|
+ switch(aStyle) {
|
|
+ case NS_FONT_STYLE_ITALIC:
|
|
+ return PANGO_STYLE_OBLIQUE;
|
|
+ break;
|
|
+ case NS_FONT_STYLE_OBLIQUE:
|
|
+ return PANGO_STYLE_OBLIQUE;
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ return PANGO_STYLE_NORMAL;
|
|
+}
|
|
+
|
|
+/* static */
|
|
+PangoWeight
|
|
+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 PANGO_WEIGHT value */
|
|
+ static int fcWeights[5] = {
|
|
+ 349,
|
|
+ 499,
|
|
+ 649,
|
|
+ 749,
|
|
+ 999
|
|
+ };
|
|
+
|
|
+ return (PangoWeight)fcWeights[fcWeight];
|
|
+}
|
|
+
|
|
+/* static */
|
|
+nsresult
|
|
+EnumFontsPango(nsIAtom* aLangGroup, const char* aGeneric,
|
|
+ PRUint32* aCount, PRUnichar*** aResult)
|
|
+{
|
|
+ FcPattern *pat = NULL;
|
|
+ FcObjectSet *os = NULL;
|
|
+ FcFontSet *fs = NULL;
|
|
+ nsresult rv = NS_ERROR_FAILURE;
|
|
+
|
|
+ PRUnichar **array = NULL;
|
|
+ PRUint32 narray = 0;
|
|
+ PRInt32 serif = 0, sansSerif = 0, monospace = 0, nGenerics;
|
|
+
|
|
+ *aCount = 0;
|
|
+ *aResult = nsnull;
|
|
+
|
|
+ pat = FcPatternCreate();
|
|
+ if (!pat)
|
|
+ goto end;
|
|
+
|
|
+ os = FcObjectSetBuild(FC_FAMILY, FC_FOUNDRY, NULL);
|
|
+ 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->nfont) {
|
|
+ rv = NS_OK;
|
|
+ goto end;
|
|
+ }
|
|
+
|
|
+ // Fontconfig supports 3 generic fonts, "serif", "sans-serif", and
|
|
+ // "monospace", slightly different from CSS's 5.
|
|
+ if (!aGeneric)
|
|
+ serif = sansSerif = monospace = 1;
|
|
+ else if (!strcmp(aGeneric, "serif"))
|
|
+ serif = 1;
|
|
+ else if (!strcmp(aGeneric, "sans-serif"))
|
|
+ sansSerif = 1;
|
|
+ else if (!strcmp(aGeneric, "monospace"))
|
|
+ monospace = 1;
|
|
+ else if (!strcmp(aGeneric, "cursive") || !strcmp(aGeneric, "fantasy"))
|
|
+ serif = sansSerif = 1;
|
|
+ else
|
|
+ NS_NOTREACHED("unexpected generic family");
|
|
+ nGenerics = serif + sansSerif + monospace;
|
|
+
|
|
+ array = NS_STATIC_CAST(PRUnichar **,
|
|
+ nsMemory::Alloc((fs->nfont + nGenerics) * sizeof(PRUnichar *)));
|
|
+ if (!array)
|
|
+ goto end;
|
|
+
|
|
+ if (serif) {
|
|
+ PRUnichar *name = ToNewUnicode(NS_LITERAL_STRING("serif"));
|
|
+ if (!name)
|
|
+ goto end;
|
|
+ array[narray++] = name;
|
|
+ }
|
|
+
|
|
+ if (sansSerif) {
|
|
+ PRUnichar *name = ToNewUnicode(NS_LITERAL_STRING("sans-serif"));
|
|
+ if (!name)
|
|
+ goto end;
|
|
+ array[narray++] = name;
|
|
+ }
|
|
+
|
|
+ if (monospace) {
|
|
+ PRUnichar *name = ToNewUnicode(NS_LITERAL_STRING("monospace"));
|
|
+ if (!name)
|
|
+ goto end;
|
|
+ array[narray++] = name;
|
|
+ }
|
|
+
|
|
+ for (int i=0; i < fs->nfont; ++i) {
|
|
+ char *family;
|
|
+
|
|
+ // if there's no family, just move to the next iteration
|
|
+ if (FcPatternGetString (fs->fonts[i], FC_FAMILY, 0,
|
|
+ (FcChar8 **) &family) != FcResultMatch) {
|
|
+ continue;
|
|
+ }
|
|
+
|
|
+ // fontconfig always returns family names in UTF-8
|
|
+ PRUnichar* name = UTF8ToNewUnicode(nsDependentCString(family));
|
|
+
|
|
+ if (!name)
|
|
+ goto end;
|
|
+
|
|
+ array[narray++] = name;
|
|
+ }
|
|
+
|
|
+ NS_QuickSort(array + nGenerics, narray - nGenerics, sizeof (PRUnichar*),
|
|
+ CompareFontNames, nsnull);
|
|
+
|
|
+ *aCount = narray;
|
|
+ if (narray)
|
|
+ *aResult = array;
|
|
+ else
|
|
+ nsMemory::Free(array);
|
|
+
|
|
+ rv = NS_OK;
|
|
+
|
|
+ end:
|
|
+ if (NS_FAILED(rv) && array) {
|
|
+ while (narray)
|
|
+ nsMemory::Free (array[--narray]);
|
|
+ nsMemory::Free (array);
|
|
+ }
|
|
+ if (pat)
|
|
+ FcPatternDestroy(pat);
|
|
+ if (os)
|
|
+ FcObjectSetDestroy(os);
|
|
+ if (fs)
|
|
+ FcFontSetDestroy(fs);
|
|
+
|
|
+ return rv;
|
|
+}
|
|
+
|
|
+/* 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);
|
|
+}
|
|
+
|
|
+
|
|
+// nsFontEnumeratorPango class
|
|
+
|
|
+nsFontEnumeratorPango::nsFontEnumeratorPango()
|
|
+{
|
|
+}
|
|
+
|
|
+NS_IMPL_ISUPPORTS1(nsFontEnumeratorPango, nsIFontEnumerator)
|
|
+
|
|
+NS_IMETHODIMP
|
|
+nsFontEnumeratorPango::EnumerateAllFonts(PRUint32 *aCount,
|
|
+ PRUnichar ***aResult)
|
|
+{
|
|
+ NS_ENSURE_ARG_POINTER(aResult);
|
|
+ *aResult = nsnull;
|
|
+ NS_ENSURE_ARG_POINTER(aCount);
|
|
+ *aCount = 0;
|
|
+
|
|
+ return EnumFontsPango(nsnull, nsnull, aCount, aResult);
|
|
+}
|
|
+
|
|
+NS_IMETHODIMP
|
|
+nsFontEnumeratorPango::EnumerateFonts(const char *aLangGroup,
|
|
+ const char *aGeneric,
|
|
+ PRUint32 *aCount,
|
|
+ PRUnichar ***aResult)
|
|
+{
|
|
+ NS_ENSURE_ARG_POINTER(aResult);
|
|
+ *aResult = nsnull;
|
|
+ NS_ENSURE_ARG_POINTER(aCount);
|
|
+ *aCount = 0;
|
|
+
|
|
+ // aLangGroup=null or "" means any (i.e., don't care)
|
|
+ // aGeneric=null or "" means any (i.e, don't care)
|
|
+ nsCOMPtr<nsIAtom> langGroup;
|
|
+ if (aLangGroup && *aLangGroup)
|
|
+ langGroup = do_GetAtom(aLangGroup);
|
|
+ const char* generic = nsnull;
|
|
+ if (aGeneric && *aGeneric)
|
|
+ generic = aGeneric;
|
|
+
|
|
+ return EnumFontsPango(langGroup, generic, aCount, aResult);
|
|
+}
|
|
+
|
|
+NS_IMETHODIMP
|
|
+nsFontEnumeratorPango::HaveFontFor(const char *aLangGroup,
|
|
+ PRBool *aResult)
|
|
+{
|
|
+ NS_ENSURE_ARG_POINTER(aResult);
|
|
+ *aResult = PR_FALSE;
|
|
+ NS_ENSURE_ARG_POINTER(aLangGroup);
|
|
+
|
|
+ *aResult = PR_TRUE; // always return true for now.
|
|
+ // Finish me - ftang
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+NS_IMETHODIMP
|
|
+nsFontEnumeratorPango::GetDefaultFont(const char *aLangGroup,
|
|
+ const char *aGeneric,
|
|
+ PRUnichar **aResult)
|
|
+{
|
|
+ NS_ENSURE_ARG_POINTER(aResult);
|
|
+ *aResult = nsnull;
|
|
+
|
|
+ // Have a look at nsFontEnumeratorXft::GetDefaultFont for some
|
|
+ // possible code for this function.
|
|
+
|
|
+ return NS_OK;
|
|
+}
|
|
+
|
|
+NS_IMETHODIMP
|
|
+nsFontEnumeratorPango::UpdateFontList(PRBool *_retval)
|
|
+{
|
|
+ *_retval = PR_FALSE; // always return false for now
|
|
+ return NS_OK;
|
|
+}
|
|
Index: gfx/src/ps/nsFontMetricsPSPango.h
|
|
===================================================================
|
|
RCS file: gfx/src/ps/nsFontMetricsPSPango.h
|
|
diff -N gfx/src/ps/nsFontMetricsPSPango.h
|
|
--- /dev/null 1 Jan 1970 00:00:00 -0000
|
|
+++ gfx/src/ps/nsFontMetricsPSPango.h 23 Oct 2006 17:37:13 -0000
|
|
@@ -0,0 +1,305 @@
|
|
+/* -*- 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) 2002
|
|
+ * 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 nsFontMetricsPSPango_h__
|
|
+#define nsFontMetricsPSPango_h__
|
|
+
|
|
+#include "nsIFontMetrics.h"
|
|
+#include "nsIFontEnumerator.h"
|
|
+#include "nsCRT.h"
|
|
+#include "nsIAtom.h"
|
|
+#include "nsString.h"
|
|
+#include "nsVoidArray.h"
|
|
+#include "nsFontMetricsPS.h"
|
|
+
|
|
+#include <pango/pango.h>
|
|
+
|
|
+class nsRenderingContextPS;
|
|
+class nsIDrawingSurface;
|
|
+
|
|
+class nsFontMetricsPSPango : public nsFontMetricsPS
|
|
+{
|
|
+public:
|
|
+ nsFontMetricsPSPango();
|
|
+ virtual ~nsFontMetricsPSPango();
|
|
+
|
|
+ NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
|
|
+
|
|
+ // nsISupports
|
|
+ NS_DECL_ISUPPORTS
|
|
+
|
|
+ // nsIFontMetrics
|
|
+ NS_IMETHOD Init (const nsFont& aFont, nsIAtom* aLangGroup,
|
|
+ nsIDeviceContext *aContext);
|
|
+ NS_IMETHOD Destroy();
|
|
+ NS_IMETHOD GetLangGroup (nsIAtom** aLangGroup);
|
|
+ NS_IMETHOD GetFontHandle (nsFontHandle &aHandle);
|
|
+
|
|
+ NS_IMETHOD GetXHeight (nscoord& aResult)
|
|
+ { aResult = mXHeight; return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetSuperscriptOffset (nscoord& aResult)
|
|
+ { aResult = mSuperscriptOffset;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetSubscriptOffset (nscoord& aResult)
|
|
+ { aResult = mSubscriptOffset;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetStrikeout (nscoord& aOffset, nscoord& aSize)
|
|
+ { aOffset = mStrikeoutOffset;
|
|
+ aSize = mStrikeoutSize;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetUnderline (nscoord& aOffset, nscoord& aSize)
|
|
+ { aOffset = mUnderlineOffset;
|
|
+ aSize = mUnderlineSize;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetHeight (nscoord &aHeight)
|
|
+ { aHeight = mMaxHeight;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetNormalLineHeight (nscoord &aHeight)
|
|
+ { aHeight = mEmHeight + mLeading;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetLeading (nscoord &aLeading)
|
|
+ { aLeading = mLeading;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetEmHeight (nscoord &aHeight)
|
|
+ { aHeight = mEmHeight;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetEmAscent (nscoord &aAscent)
|
|
+ { aAscent = mEmAscent;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetEmDescent (nscoord &aDescent)
|
|
+ { aDescent = mEmDescent;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetMaxHeight (nscoord &aHeight)
|
|
+ { aHeight = mMaxHeight;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetMaxAscent (nscoord &aAscent)
|
|
+ { aAscent = mMaxAscent;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetMaxDescent (nscoord &aDescent)
|
|
+ { aDescent = mMaxDescent;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetMaxAdvance (nscoord &aAdvance)
|
|
+ { aAdvance = mMaxAdvance;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetSpaceWidth (nscoord &aSpaceCharWidth)
|
|
+ { aSpaceCharWidth = mSpaceWidth;
|
|
+ return NS_OK; };
|
|
+
|
|
+ NS_IMETHOD GetAveCharWidth (nscoord &aAveCharWidth)
|
|
+ { aAveCharWidth = mAveCharWidth;
|
|
+ return NS_OK; };
|
|
+
|
|
+ // nsIFontMetricsPS (calls from the font rendering layer)
|
|
+ NS_IMETHOD GetStringWidth(const char *String,nscoord &aWidth,nscoord aLength);
|
|
+ NS_IMETHOD GetStringWidth(const PRUnichar *aString,nscoord &aWidth,nscoord aLength);
|
|
+
|
|
+ NS_IMETHOD GetWidth(const char* aString, PRUint32 aLength,
|
|
+ nscoord& aWidth);
|
|
+ NS_IMETHOD GetWidth(const PRUnichar* aString, PRUint32 aLength,
|
|
+ nscoord& aWidth);
|
|
+
|
|
+ NS_IMETHOD GetTextDimensions(const char* aString,
|
|
+ PRUint32 aLength,
|
|
+ nsTextDimensions& aDimensions);
|
|
+ NS_IMETHOD GetTextDimensions(const PRUnichar* aString,
|
|
+ PRUint32 aLength,
|
|
+ nsTextDimensions& aDimensions,
|
|
+ PRInt32* aFontID);
|
|
+ NS_IMETHOD GetTextDimensions(const char* aString,
|
|
+ PRInt32 aLength,
|
|
+ PRInt32 aAvailWidth,
|
|
+ PRInt32* aBreaks,
|
|
+ PRInt32 aNumBreaks,
|
|
+ nsTextDimensions& aDimensions,
|
|
+ PRInt32& aNumCharsFit,
|
|
+ nsTextDimensions& aLastWordDimensions,
|
|
+ PRInt32* aFontID);
|
|
+ NS_IMETHOD GetTextDimensions(const PRUnichar* aString,
|
|
+ PRInt32 aLength,
|
|
+ PRInt32 aAvailWidth,
|
|
+ PRInt32* aBreaks,
|
|
+ PRInt32 aNumBreaks,
|
|
+ nsTextDimensions& aDimensions,
|
|
+ PRInt32& aNumCharsFit,
|
|
+ nsTextDimensions& aLastWordDimensions,
|
|
+ PRInt32* aFontID);
|
|
+
|
|
+ NS_IMETHOD DrawString(const char *aString, PRUint32 aLength,
|
|
+ nscoord aX, nscoord aY,
|
|
+ const nscoord* aSpacing,
|
|
+ nsRenderingContextPS *aContext);
|
|
+ NS_IMETHOD DrawString(const PRUnichar* aString, PRUint32 aLength,
|
|
+ nscoord aX, nscoord aY,
|
|
+ PRInt32 aFontID,
|
|
+ const nscoord* aSpacing,
|
|
+ nsRenderingContextPS *aContext);
|
|
+
|
|
+#ifdef MOZ_MATHML
|
|
+ NS_IMETHOD GetBoundingMetrics(const char *aString, PRUint32 aLength,
|
|
+ nsBoundingMetrics &aBoundingMetrics);
|
|
+ NS_IMETHOD GetBoundingMetrics(const PRUnichar *aString,
|
|
+ PRUint32 aLength,
|
|
+ nsBoundingMetrics &aBoundingMetrics,
|
|
+ PRInt32 *aFontID);
|
|
+#endif /* MOZ_MATHML */
|
|
+
|
|
+ NS_IMETHOD SetRightToLeftText(PRBool aIsRTL);
|
|
+
|
|
+ NS_IMETHOD GetClusterInfo(const PRUnichar *aText,
|
|
+ PRUint32 aLength,
|
|
+ PRUint8 *aClusterStarts);
|
|
+
|
|
+ virtual PRInt32 GetPosition(const PRUnichar *aText,
|
|
+ PRUint32 aLength,
|
|
+ nsPoint aPt);
|
|
+
|
|
+ NS_IMETHOD GetRangeWidth(const PRUnichar *aText,
|
|
+ PRUint32 aLength,
|
|
+ PRUint32 aStart,
|
|
+ PRUint32 aEnd,
|
|
+ PRUint32 &aWidth);
|
|
+
|
|
+ NS_IMETHOD GetRangeWidth(const char *aText,
|
|
+ PRUint32 aLength,
|
|
+ PRUint32 aStart,
|
|
+ PRUint32 aEnd,
|
|
+ PRUint32 &aWidth);
|
|
+
|
|
+ // get hints for the font
|
|
+ virtual PRUint32 GetHints (void);
|
|
+
|
|
+ // drawing surface methods
|
|
+ static nsresult FamilyExists (nsIDeviceContext *aDevice,
|
|
+ const nsString &aName);
|
|
+
|
|
+ inline nsIDeviceContext *GetDeviceContext() { return mDeviceContext; }
|
|
+
|
|
+private:
|
|
+
|
|
+ // generic font metrics class bits
|
|
+ nsCStringArray mFontList;
|
|
+ nsAutoVoidArray mFontIsGeneric;
|
|
+
|
|
+ nsIDeviceContext *mDeviceContext;
|
|
+ nsCOMPtr<nsIAtom> mLangGroup;
|
|
+ nsCString *mGenericFont;
|
|
+ float mPointSize;
|
|
+
|
|
+ nsCAutoString mDefaultFont;
|
|
+
|
|
+ // Pango-related items
|
|
+ PangoFontDescription *mPangoFontDesc;
|
|
+ PangoContext *mPangoContext;
|
|
+ PangoContext *mLTRPangoContext;
|
|
+ PangoContext *mRTLPangoContext;
|
|
+ PangoAttrList *mPangoAttrList;
|
|
+ PRBool mIsRTL;
|
|
+
|
|
+ // Cached font metrics
|
|
+ nscoord mXHeight;
|
|
+ nscoord mSuperscriptOffset;
|
|
+ nscoord mSubscriptOffset;
|
|
+ nscoord mStrikeoutOffset;
|
|
+ nscoord mStrikeoutSize;
|
|
+ nscoord mUnderlineOffset;
|
|
+ nscoord mUnderlineSize;
|
|
+ nscoord mMaxHeight;
|
|
+ nscoord mLeading;
|
|
+ nscoord mEmHeight;
|
|
+ nscoord mEmAscent;
|
|
+ nscoord mEmDescent;
|
|
+ nscoord mMaxAscent;
|
|
+ nscoord mMaxDescent;
|
|
+ nscoord mMaxAdvance;
|
|
+ nscoord mSpaceWidth;
|
|
+ nscoord mPangoSpaceWidth;
|
|
+ nscoord mAveCharWidth;
|
|
+
|
|
+ // Private methods
|
|
+ nsresult RealizeFont(void);
|
|
+ nsresult CacheFontMetrics(void);
|
|
+
|
|
+ static PRBool EnumFontCallback(const nsString &aFamily,
|
|
+ PRBool aIsGeneric, void *aData);
|
|
+
|
|
+ void DrawStringSlowly(const gchar *aText,
|
|
+ const PRUnichar *aOrigString,
|
|
+ PRUint32 aLength,
|
|
+ gint aX, gint aY,
|
|
+ PangoLayoutLine *aLine,
|
|
+ const nscoord *aSpacing,
|
|
+ nsRenderingContextPS *aContext);
|
|
+
|
|
+ nsresult GetTextDimensionsInternal(const gchar* aString,
|
|
+ PRInt32 aLength,
|
|
+ PRInt32 aAvailWidth,
|
|
+ PRInt32* aBreaks,
|
|
+ PRInt32 aNumBreaks,
|
|
+ nsTextDimensions& aDimensions,
|
|
+ PRInt32& aNumCharsFit,
|
|
+ nsTextDimensions& aLastWordDimensions);
|
|
+
|
|
+ void FixupSpaceWidths (PangoLayout *aLayout, const char *aString);
|
|
+};
|
|
+
|
|
+class nsFontEnumeratorPango : public nsIFontEnumerator
|
|
+{
|
|
+public:
|
|
+ nsFontEnumeratorPango();
|
|
+ NS_DECL_ISUPPORTS
|
|
+ NS_DECL_NSIFONTENUMERATOR
|
|
+};
|
|
+
|
|
+#endif
|
|
+
|
|
Index: gfx/src/ps/nsPostScriptObj.cpp
|
|
===================================================================
|
|
RCS file: /cvsroot/mozilla/gfx/src/ps/nsPostScriptObj.cpp,v
|
|
retrieving revision 1.124
|
|
diff -u -p -d -r1.124 nsPostScriptObj.cpp
|
|
--- gfx/src/ps/nsPostScriptObj.cpp 26 Jul 2005 15:54:18 -0000 1.124
|
|
+++ gfx/src/ps/nsPostScriptObj.cpp 23 Oct 2006 17:37:29 -0000
|
|
@@ -2061,31 +2061,74 @@ nsPostScriptObj::show(const PRUnichar* t
|
|
|
|
#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
|
|
void
|
|
-nsPostScriptObj::show(const PRUnichar* aTxt, int aLen,
|
|
- const nsAFlatString& aCharList, PRUint16 aSubFontIdx)
|
|
+/*nsPostScriptObj::show(const PRUnichar* aTxt, int aLen,
|
|
+ const nsAFlatString& aCharList, PRUint16 aSubFontIdx) */
|
|
+nsPostScriptObj::show(const nsValueArray *aGlyphs, nsPSFontGenerator *aSubset,
|
|
+ PRUint16 aSubFontIdx)
|
|
{
|
|
- int i;
|
|
+ PRUint32 i;
|
|
fputc('<', mScriptFP);
|
|
|
|
- const PRUint16 subFontSize = nsPSFontGenerator::kSubFontSize;
|
|
+ for (i = 0; i < aGlyphs->Count(); i++) {
|
|
+ PRUint32 glyph = aGlyphs->ValueAt(i);
|
|
+ fprintf(mScriptFP, "%02x", aSubset->InSubsetIndexOf(glyph));
|
|
+ }
|
|
|
|
- // the character repertoire of a subfont (255 characters max)
|
|
- const nsAString& repertoire =
|
|
- Substring(aCharList, aSubFontIdx * subFontSize,
|
|
- PR_MIN(subFontSize,
|
|
- aCharList.Length() - aSubFontIdx * subFontSize));
|
|
+ fputs("> show\n", mScriptFP);
|
|
+}
|
|
+#endif
|
|
|
|
- for (i = 0; i < aLen; i++) {
|
|
- // XXX This is a little inefficient, but printing is not perf. critical.
|
|
- NS_ASSERTION(repertoire.FindChar(aTxt[i]) != kNotFound,
|
|
- "character is not covered by this subfont");
|
|
-
|
|
- // Type 1 encoding vector has 256 slots, but the 0-th slot is
|
|
- // reserved for /.notdef so that we use the 1st through 255th slots
|
|
- // for actual characters (hence '+ 1')
|
|
- fprintf(mScriptFP, "%02x", repertoire.FindChar(aTxt[i]) + 1);
|
|
+#ifdef MOZ_ENABLE_PANGO
|
|
+void
|
|
+nsPostScriptObj::show(const PangoGlyphString *glyphs, float zoom,
|
|
+ nsPSFontGenerator *aSubset, PRUint16 aSubFontIdx)
|
|
+{
|
|
+ PRUint32 i;
|
|
+ int horiz = 1;
|
|
+
|
|
+ if (glyphs->glyphs[0].geometry.x_offset || glyphs->glyphs[0].geometry.y_offset)
|
|
+ rmoveto (NSToCoordRound (zoom * glyphs->glyphs[0].geometry.x_offset / PANGO_SCALE),
|
|
+ NSToCoordRound (zoom * glyphs->glyphs[0].geometry.y_offset / PANGO_SCALE));
|
|
+
|
|
+ fputc('<', mScriptFP);
|
|
+
|
|
+ for (i = 0; i < glyphs->num_glyphs; i++) {
|
|
+ PRUint32 glyph = glyphs->glyphs[i].glyph;
|
|
+ fprintf(mScriptFP, "%02x", aSubset->InSubsetIndexOf(glyph));
|
|
+ if (glyphs->glyphs[i].geometry.y_offset)
|
|
+ horiz = 0;
|
|
+ }
|
|
+
|
|
+ if (horiz) {
|
|
+ fputs(">\n[", mScriptFP);
|
|
+ for (i = 1; i < glyphs->num_glyphs; i++) {
|
|
+ fprintf(mScriptFP, "%d ",
|
|
+ NSToCoordRound (zoom * (+ glyphs->glyphs[i ].geometry.x_offset
|
|
+ + glyphs->glyphs[i-1].geometry.width
|
|
+ - glyphs->glyphs[i-1].geometry.x_offset) / PANGO_SCALE));
|
|
+ }
|
|
+ fprintf(mScriptFP, "%d",
|
|
+ NSToCoordRound (zoom * (+ glyphs->glyphs[i-1].geometry.width
|
|
+ - glyphs->glyphs[i-1].geometry.x_offset
|
|
+ - glyphs->glyphs[ 0].geometry.x_offset) / PANGO_SCALE));
|
|
+ fputs("] xshow\n", mScriptFP);
|
|
+ } else {
|
|
+ fputs(">\n[", mScriptFP);
|
|
+ for (i = 1; i < glyphs->num_glyphs; i++) {
|
|
+ fprintf(mScriptFP, "%d %d ",
|
|
+ NSToCoordRound (zoom * (+ glyphs->glyphs[i ].geometry.x_offset
|
|
+ + glyphs->glyphs[i-1].geometry.width
|
|
+ - glyphs->glyphs[i-1].geometry.x_offset) / PANGO_SCALE),
|
|
+ NSToCoordRound (zoom * (+ glyphs->glyphs[i ].geometry.y_offset
|
|
+ - glyphs->glyphs[i-1].geometry.y_offset) / PANGO_SCALE));
|
|
+ }
|
|
+ fprintf(mScriptFP, "%d %d",
|
|
+ NSToCoordRound (zoom * (+ glyphs->glyphs[i-1].geometry.width
|
|
+ - glyphs->glyphs[i-1].geometry.x_offset
|
|
+ - glyphs->glyphs[ 0].geometry.x_offset) / PANGO_SCALE),
|
|
+ NSToCoordRound (zoom * (- glyphs->glyphs[i-1].geometry.y_offset) / PANGO_SCALE));
|
|
+ fputs("] xyshow\n", mScriptFP);
|
|
}
|
|
- fputs("> show\n", mScriptFP);
|
|
}
|
|
#endif
|
|
|
|
@@ -2101,6 +2144,16 @@ nsPostScriptObj::moveto(nscoord x, nscoo
|
|
|
|
/** ---------------------------------------------------
|
|
* See documentation in nsPostScriptObj.h
|
|
+ * @update 10/20/06 behdad
|
|
+ */
|
|
+void
|
|
+nsPostScriptObj::rmoveto(nscoord x, nscoord y)
|
|
+{
|
|
+ fprintf(mScriptFP, "%d %d rmoveto\n", x, y);
|
|
+}
|
|
+
|
|
+/** ---------------------------------------------------
|
|
+ * See documentation in nsPostScriptObj.h
|
|
* @update 2/1/99 dwc
|
|
*/
|
|
void
|
|
Index: gfx/src/ps/nsPostScriptObj.h
|
|
===================================================================
|
|
RCS file: /cvsroot/mozilla/gfx/src/ps/nsPostScriptObj.h,v
|
|
retrieving revision 1.47
|
|
diff -u -p -d -r1.47 nsPostScriptObj.h
|
|
--- gfx/src/ps/nsPostScriptObj.h 8 May 2005 15:01:20 -0000 1.47
|
|
+++ gfx/src/ps/nsPostScriptObj.h 23 Oct 2006 17:37:30 -0000
|
|
@@ -57,9 +57,15 @@
|
|
#include "nsIPersistentProperties2.h"
|
|
#include "nsTempfilePS.h"
|
|
#include "nsEPSObjectPS.h"
|
|
+#ifdef MOZ_ENABLE_PANGO
|
|
+#include <pango/pango.h>
|
|
+#endif
|
|
+
|
|
|
|
+class nsPSFontGenerator;
|
|
class nsIImage;
|
|
class nsIAtom;
|
|
+class nsValueArray;
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
@@ -217,6 +223,14 @@ public:
|
|
*/
|
|
void moveto(nscoord aX, nscoord aY);
|
|
/** ---------------------------------------------------
|
|
+ * Move relative to the current point
|
|
+ * @update 10/20/2006 behdad
|
|
+ * @param aX X coordinate
|
|
+ * aY Y coordinate
|
|
+ * @return VOID
|
|
+ */
|
|
+ void rmoveto(nscoord aX, nscoord aY);
|
|
+ /** ---------------------------------------------------
|
|
* Add a line to the current path, from the current point
|
|
* to the specified point.
|
|
* @update 9/30/2003
|
|
@@ -346,12 +360,24 @@ public:
|
|
*/
|
|
void show(const PRUnichar* aText, int aLen, const char *aAlign, int aType);
|
|
/** ---------------------------------------------------
|
|
- * This version takes a PRUnichar string, a font subset string
|
|
- * for freetype printing and a subfont index
|
|
+ * This version of show takes an array of glyphs, subfont and subfont index
|
|
+ * to render and is used for freetype and xft printing.
|
|
* @update 2/15/2005 jshin@mailaps.org
|
|
+ * @update 6/7/2005 blizzard@mozilla.org
|
|
*/
|
|
- void show(const PRUnichar* aText, int aLen, const nsAFlatString& aCharList,
|
|
+ void show(const nsValueArray *aGlyphs, nsPSFontGenerator *aSubset,
|
|
PRUint16 aSubFontIdx);
|
|
+ /*void show(const PRUnichar* aText, int aLen, const nsAFlatString& aCharList,
|
|
+ PRUint16 aSubFontIdx); */
|
|
+#ifdef MOZ_ENABLE_PANGO
|
|
+ /** ---------------------------------------------------
|
|
+ * This version of show takes a pango glyph string, subfont and subfont index
|
|
+ * to render and is used for pango printing.
|
|
+ * @update 10/20/2006 behdad@behdad.org
|
|
+ */
|
|
+ void show(const PangoGlyphString *glyphs, float zoom,
|
|
+ nsPSFontGenerator *aSubset, PRUint16 aSubFontIdx);
|
|
+#endif
|
|
/** ---------------------------------------------------
|
|
* set the clipping path to the current path using the winding rule
|
|
* @update 2/1/99 dwc
|
|
Index: gfx/src/ps/nsRenderingContextPS.cpp
|
|
===================================================================
|
|
RCS file: /cvsroot/mozilla/gfx/src/ps/nsRenderingContextPS.cpp,v
|
|
retrieving revision 1.83
|
|
diff -u -p -d -r1.83 nsRenderingContextPS.cpp
|
|
--- gfx/src/ps/nsRenderingContextPS.cpp 4 Mar 2005 07:39:27 -0000 1.83
|
|
+++ gfx/src/ps/nsRenderingContextPS.cpp 23 Oct 2006 17:37:31 -0000
|
|
@@ -251,6 +251,8 @@ nsRenderingContextPS :: GetDrawingSurfac
|
|
NS_IMETHODIMP
|
|
nsRenderingContextPS :: GetHints(PRUint32& aResult)
|
|
{
|
|
+ nsFontMetricsPS *metrics = NS_REINTERPRET_CAST(nsFontMetricsPS *, mFontMetrics.get());
|
|
+ aResult = metrics->GetHints ();
|
|
return NS_OK;
|
|
}
|
|
|
|
@@ -1006,8 +1008,11 @@ nsRenderingContextPS::GetTextDimensions(
|
|
nsTextDimensions& aLastWordDimensions,
|
|
PRInt32* aFontID)
|
|
{
|
|
- NS_NOTYETIMPLEMENTED("nsRenderingContextPS::GetTextDimensions");
|
|
- return NS_ERROR_NOT_IMPLEMENTED;
|
|
+ NS_ENSURE_TRUE(mFontMetrics, NS_ERROR_NULL_POINTER);
|
|
+ nsFontMetricsPS *metrics = NS_REINTERPRET_CAST(nsFontMetricsPS *, mFontMetrics.get());
|
|
+ NS_ENSURE_TRUE(metrics, NS_ERROR_FAILURE);
|
|
+ return metrics->GetTextDimensions (aString, aLength, aAvailWidth, aBreaks, aNumBreaks,
|
|
+ aDimensions, aNumCharsFit, aLastWordDimensions, aFontID);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
@@ -1021,43 +1026,31 @@ nsRenderingContextPS::GetTextDimensions(
|
|
nsTextDimensions& aLastWordDimensions,
|
|
PRInt32* aFontID)
|
|
{
|
|
- NS_NOTYETIMPLEMENTED("nsRenderingContextPS::GetTextDimensions");
|
|
- return NS_ERROR_NOT_IMPLEMENTED;
|
|
+ NS_ENSURE_TRUE(mFontMetrics, NS_ERROR_NULL_POINTER);
|
|
+ nsFontMetricsPS *metrics = NS_REINTERPRET_CAST(nsFontMetricsPS *, mFontMetrics.get());
|
|
+ NS_ENSURE_TRUE(metrics, NS_ERROR_FAILURE);
|
|
+ return metrics->GetTextDimensions (aString, aLength, aAvailWidth, aBreaks, aNumBreaks,
|
|
+ aDimensions, aNumCharsFit, aLastWordDimensions, aFontID);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsRenderingContextPS :: GetTextDimensions(const char* aString, PRUint32 aLength,
|
|
nsTextDimensions& aDimensions)
|
|
{
|
|
- nsresult rv = NS_ERROR_FAILURE;
|
|
-
|
|
- if (mFontMetrics) {
|
|
- nsFontMetricsPS *metrics = NS_REINTERPRET_CAST(nsFontMetricsPS *, mFontMetrics.get());
|
|
- metrics->GetStringWidth(aString, aDimensions.width, aLength);
|
|
- metrics->GetMaxAscent(aDimensions.ascent);
|
|
- metrics->GetMaxDescent(aDimensions.descent);
|
|
- rv = NS_OK;
|
|
- }
|
|
-
|
|
- return rv;
|
|
+ NS_ENSURE_TRUE(mFontMetrics, NS_ERROR_NULL_POINTER);
|
|
+ nsFontMetricsPS *metrics = NS_REINTERPRET_CAST(nsFontMetricsPS *, mFontMetrics.get());
|
|
+ NS_ENSURE_TRUE(metrics, NS_ERROR_FAILURE);
|
|
+ return metrics->GetTextDimensions (aString, aLength, aDimensions);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsRenderingContextPS :: GetTextDimensions(const PRUnichar* aString, PRUint32 aLength,
|
|
nsTextDimensions& aDimensions, PRInt32* aFontID)
|
|
{
|
|
- nsresult rv = NS_ERROR_FAILURE;
|
|
-
|
|
- if (mFontMetrics) {
|
|
- nsFontMetricsPS *metrics = NS_REINTERPRET_CAST(nsFontMetricsPS *, mFontMetrics.get());
|
|
- metrics->GetStringWidth(aString, aDimensions.width, aLength);
|
|
- //XXX temporary - bug 96609
|
|
- metrics->GetMaxAscent(aDimensions.ascent);
|
|
- metrics->GetMaxDescent(aDimensions.descent);
|
|
- rv = NS_OK;
|
|
- }
|
|
-
|
|
- return rv;
|
|
+ NS_ENSURE_TRUE(mFontMetrics, NS_ERROR_NULL_POINTER);
|
|
+ nsFontMetricsPS *metrics = NS_REINTERPRET_CAST(nsFontMetricsPS *, mFontMetrics.get());
|
|
+ NS_ENSURE_TRUE(metrics, NS_ERROR_FAILURE);
|
|
+ return metrics->GetTextDimensions (aString, aLength, aDimensions, aFontID);
|
|
}
|
|
|
|
/** ---------------------------------------------------
|
|
@@ -1073,47 +1066,7 @@ nsRenderingContextPS :: DrawString(const
|
|
|
|
nsFontMetricsPS *metrics = NS_REINTERPRET_CAST(nsFontMetricsPS *, mFontMetrics.get());
|
|
NS_ENSURE_TRUE(metrics, NS_ERROR_FAILURE);
|
|
-
|
|
- // When FT2 printing is enabled, we don't need to set langgroup
|
|
-#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
|
|
- if (!NS_REINTERPRET_CAST(nsDeviceContextPS *, mContext.get())->mFTPEnable) {
|
|
-#endif
|
|
- nsCOMPtr<nsIAtom> langGroup;
|
|
- mFontMetrics->GetLangGroup(getter_AddRefs(langGroup));
|
|
- mPSObj->setlanggroup(langGroup);
|
|
-#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
|
|
- }
|
|
-#endif
|
|
-
|
|
- if (aLength == 0)
|
|
- return NS_OK;
|
|
- nsFontPS* fontPS = nsFontPS::FindFont(aString[0], metrics->Font(), metrics);
|
|
- NS_ENSURE_TRUE(fontPS, NS_ERROR_FAILURE);
|
|
- fontPS->SetupFont(this);
|
|
-
|
|
- PRUint32 i, start = 0;
|
|
- for (i=0; i<aLength; i++) {
|
|
- nsFontPS* fontThisChar;
|
|
- fontThisChar = nsFontPS::FindFont(aString[i], metrics->Font(), metrics);
|
|
- NS_ENSURE_TRUE(fontThisChar, NS_ERROR_FAILURE);
|
|
- if (fontThisChar != fontPS) {
|
|
- // draw text up to this point
|
|
- aX += DrawString(aString+start, i-start, aX, aY, fontPS,
|
|
- aSpacing?aSpacing+start:nsnull);
|
|
- start = i;
|
|
-
|
|
- // setup for following text
|
|
- fontPS = fontThisChar;
|
|
- fontPS->SetupFont(this);
|
|
- }
|
|
- }
|
|
-
|
|
- // draw the last part
|
|
- if (aLength-start)
|
|
- DrawString(aString+start, aLength-start, aX, aY, fontPS,
|
|
- aSpacing?aSpacing+start:nsnull);
|
|
-
|
|
- return NS_OK;
|
|
+ return metrics->DrawString (aString, aLength, aX, aY, aSpacing, this);
|
|
}
|
|
|
|
/** ---------------------------------------------------
|
|
@@ -1129,110 +1082,7 @@ nsRenderingContextPS :: DrawString(const
|
|
|
|
nsFontMetricsPS *metrics = NS_REINTERPRET_CAST(nsFontMetricsPS *, mFontMetrics.get());
|
|
NS_ENSURE_TRUE(metrics, NS_ERROR_FAILURE);
|
|
-
|
|
-#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
|
|
- // When FT2 printing is enabled, we don't need to set langgroup
|
|
- if (!NS_REINTERPRET_CAST(nsDeviceContextPS *, mContext.get())->mFTPEnable) {
|
|
-#endif
|
|
- nsCOMPtr<nsIAtom> langGroup = nsnull;
|
|
- mFontMetrics->GetLangGroup(getter_AddRefs(langGroup));
|
|
- mPSObj->setlanggroup(langGroup);
|
|
-#if defined(MOZ_ENABLE_FREETYPE2) || defined(MOZ_ENABLE_XFT)
|
|
- }
|
|
-#endif
|
|
-
|
|
- /* build up conversion table */
|
|
- mPSObj->preshow(aString, aLength);
|
|
-
|
|
- if (aLength == 0)
|
|
- return NS_OK;
|
|
- nsFontPS* fontPS = nsFontPS::FindFont(aString[0], metrics->Font(), metrics);
|
|
- NS_ENSURE_TRUE(fontPS, NS_ERROR_FAILURE);
|
|
- fontPS->SetupFont(this);
|
|
-
|
|
- PRUint32 i, start = 0;
|
|
- for (i=0; i<aLength; i++) {
|
|
- nsFontPS* fontThisChar;
|
|
- fontThisChar = nsFontPS::FindFont(aString[i], metrics->Font(), metrics);
|
|
- NS_ENSURE_TRUE(fontThisChar, NS_ERROR_FAILURE);
|
|
- if (fontThisChar != fontPS) {
|
|
- // draw text up to this point
|
|
- aX += DrawString(aString+start, i-start, aX, aY, fontPS,
|
|
- aSpacing?aSpacing+start:nsnull);
|
|
- start = i;
|
|
-
|
|
- // setup for following text
|
|
- fontPS = fontThisChar;
|
|
- fontPS->SetupFont(this);
|
|
- }
|
|
- }
|
|
-
|
|
- // draw the last part
|
|
- if (aLength-start)
|
|
- DrawString(aString+start, aLength-start, aX, aY, fontPS,
|
|
- aSpacing?aSpacing+start:nsnull);
|
|
-
|
|
- return NS_OK;
|
|
-}
|
|
-
|
|
-PRInt32
|
|
-nsRenderingContextPS::DrawString(const char *aString, PRUint32 aLength,
|
|
- nscoord &aX, nscoord &aY, nsFontPS* aFontPS,
|
|
- const nscoord* aSpacing)
|
|
-{
|
|
- nscoord width = 0;
|
|
- PRInt32 x = aX;
|
|
- PRInt32 y = aY;
|
|
-
|
|
- PRInt32 dxMem[500];
|
|
- PRInt32* dx0 = 0;
|
|
- if (aSpacing) {
|
|
- dx0 = dxMem;
|
|
- if (aLength > 500) {
|
|
- dx0 = new PRInt32[aLength];
|
|
- NS_ENSURE_TRUE(dx0, NS_ERROR_OUT_OF_MEMORY);
|
|
- }
|
|
- mTranMatrix->ScaleXCoords(aSpacing, aLength, dx0);
|
|
- }
|
|
-
|
|
- mTranMatrix->TransformCoord(&x, &y);
|
|
- width = aFontPS->DrawString(this, x, y, aString, aLength);
|
|
-
|
|
- if ((aSpacing) && (dx0 != dxMem)) {
|
|
- delete [] dx0;
|
|
- }
|
|
-
|
|
- return width;
|
|
-}
|
|
-
|
|
-
|
|
-PRInt32
|
|
-nsRenderingContextPS::DrawString(const PRUnichar *aString, PRUint32 aLength,
|
|
- nscoord aX, nscoord aY, nsFontPS* aFontPS,
|
|
- const nscoord* aSpacing)
|
|
-{
|
|
- nscoord width = 0;
|
|
- PRInt32 x = aX;
|
|
- PRInt32 y = aY;
|
|
-
|
|
- if (aSpacing) {
|
|
- // Slow, but accurate rendering
|
|
- const PRUnichar* end = aString + aLength;
|
|
- while (aString < end){
|
|
- x = aX;
|
|
- y = aY;
|
|
- mTranMatrix->TransformCoord(&x, &y);
|
|
- aFontPS->DrawString(this, x, y, aString, 1);
|
|
- aX += *aSpacing++;
|
|
- aString++;
|
|
- }
|
|
- width = aX;
|
|
- } else {
|
|
- mTranMatrix->TransformCoord(&x, &y);
|
|
- width = aFontPS->DrawString(this, x, y, aString, aLength);
|
|
- }
|
|
-
|
|
- return width;
|
|
+ return metrics->DrawString (aString, aLength, aX, aY, aFontID, aSpacing, this);
|
|
}
|
|
|
|
/** ---------------------------------------------------
|
|
@@ -1346,8 +1196,10 @@ nsRenderingContextPS::GetBoundingMetrics
|
|
PRUint32 aLength,
|
|
nsBoundingMetrics& aBoundingMetrics)
|
|
{
|
|
- // Fill me up
|
|
- return NS_ERROR_NOT_IMPLEMENTED;
|
|
+ NS_ENSURE_TRUE(mFontMetrics, NS_ERROR_NULL_POINTER);
|
|
+ nsFontMetricsPS *metrics = NS_REINTERPRET_CAST(nsFontMetricsPS *, mFontMetrics.get());
|
|
+ NS_ENSURE_TRUE(metrics, NS_ERROR_FAILURE);
|
|
+ return metrics->GetBoundingMetrics (aString, aLength, aBoundingMetrics);
|
|
}
|
|
|
|
/**
|
|
@@ -1359,8 +1211,10 @@ nsRenderingContextPS::GetBoundingMetrics
|
|
nsBoundingMetrics& aBoundingMetrics,
|
|
PRInt32* aFontID)
|
|
{
|
|
- // Fill me up
|
|
- return NS_ERROR_NOT_IMPLEMENTED;
|
|
+ NS_ENSURE_TRUE(mFontMetrics, NS_ERROR_NULL_POINTER);
|
|
+ nsFontMetricsPS *metrics = NS_REINTERPRET_CAST(nsFontMetricsPS *, mFontMetrics.get());
|
|
+ NS_ENSURE_TRUE(metrics, NS_ERROR_FAILURE);
|
|
+ return metrics->GetBoundingMetrics (aString, aLength, aBoundingMetrics, aFontID);
|
|
}
|
|
#endif /* MOZ_MATHML */
|
|
|
|
Index: gfx/src/ps/nsRenderingContextPS.h
|
|
===================================================================
|
|
RCS file: /cvsroot/mozilla/gfx/src/ps/nsRenderingContextPS.h,v
|
|
retrieving revision 1.49
|
|
diff -u -p -d -r1.49 nsRenderingContextPS.h
|
|
--- gfx/src/ps/nsRenderingContextPS.h 20 Sep 2004 06:46:16 -0000 1.49
|
|
+++ gfx/src/ps/nsRenderingContextPS.h 23 Oct 2006 17:37:35 -0000
|
|
@@ -154,6 +154,10 @@ public:
|
|
NS_IMETHOD GetWidth(const PRUnichar* aString, PRUint32 aLength,
|
|
nscoord& aWidth, PRInt32 *aFontID);
|
|
|
|
+ nsTransform2D *GetTranMatrix() {
|
|
+ return mTranMatrix;
|
|
+ }
|
|
+
|
|
NS_IMETHOD DrawString(const char *aString, PRUint32 aLength,
|
|
nscoord aX, nscoord aY,
|
|
const nscoord* aSpacing);
|
|
@@ -164,13 +168,6 @@ public:
|
|
NS_IMETHOD DrawString(const nsString& aString, nscoord aX, nscoord aY,
|
|
PRInt32 aFontID,
|
|
const nscoord* aSpacing);
|
|
-protected:
|
|
- PRInt32 DrawString(const PRUnichar *aString, PRUint32 aLength,
|
|
- nscoord aX, nscoord aY, nsFontPS* aFontPS,
|
|
- const nscoord* aSpacing);
|
|
- PRInt32 DrawString(const char *aString, PRUint32 aLength,
|
|
- nscoord &aX, nscoord &aY, nsFontPS* aFontPS,
|
|
- const nscoord* aSpacing);
|
|
public:
|
|
|
|
NS_IMETHOD GetTextDimensions(const char* aString, PRUint32 aLength,
|
|
Index: gfx/src/ps/nsType1.cpp
|
|
===================================================================
|
|
RCS file: /cvsroot/mozilla/gfx/src/ps/nsType1.cpp,v
|
|
retrieving revision 1.5.8.1
|
|
diff -u -p -d -r1.5.8.1 nsType1.cpp
|
|
--- gfx/src/ps/nsType1.cpp 19 Oct 2005 08:16:22 -0000 1.5.8.1
|
|
+++ gfx/src/ps/nsType1.cpp 23 Oct 2006 17:37:39 -0000
|
|
@@ -73,8 +73,13 @@
|
|
#include "nsIFreeType2.h"
|
|
#include "nsServiceManagerUtils.h"
|
|
#endif
|
|
+#if defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
+#include FT_TYPE1_TABLES_H
|
|
+#endif
|
|
#include "nsPrintfCString.h"
|
|
#include "nsAutoBuffer.h"
|
|
+#include "nsValueArray.h"
|
|
+#include "nsVoidArray.h"
|
|
|
|
#define HEXASCII_LINE_LEN 64
|
|
|
|
@@ -113,7 +118,7 @@ static void encryptAndHexOut(FILE *aFile
|
|
const char *aBuf, PRInt32 aLen = -1);
|
|
static void charStringOut(FILE* aFile, PRUint32* aPos, PRUint16* aKey,
|
|
const char *aStr, PRUint32 aLen,
|
|
- PRUnichar aId);
|
|
+ const char *aGlyphName);
|
|
static void flattenName(nsCString& aString);
|
|
|
|
/* thunk a short name for this function */
|
|
@@ -202,19 +207,30 @@ Type1EncryptString(unsigned char *aInBuf
|
|
aOutBuf[i] = Type1Encrypt(aInBuf[i], &key);
|
|
}
|
|
|
|
+static FT_UShort
|
|
+get_upm (FT_Face face)
|
|
+{
|
|
+ FT_UShort upm = face->units_per_EM;
|
|
+
|
|
+ if (!upm)
|
|
+ upm = 1000; // bitmap font or something
|
|
+
|
|
+ return upm;
|
|
+}
|
|
+
|
|
static PRBool
|
|
sideWidthAndBearing(const FT_Vector *aEndPt, FT2PT1_info *aFti)
|
|
{
|
|
int aw = 0;
|
|
int ah = 0;
|
|
- FT_UShort upm = aFti->face->units_per_EM;
|
|
+ FT_UShort upm = get_upm (aFti->face);
|
|
FT_GlyphSlot slot;
|
|
FT_Glyph glyph;
|
|
FT_BBox bbox;
|
|
|
|
slot = aFti->face->glyph;
|
|
|
|
-#ifdef MOZ_ENABLE_XFT
|
|
+#if defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
FT_Error error = FT_Get_Glyph(slot, &glyph);
|
|
if (error) {
|
|
NS_ERROR("sideWidthAndBearing failed to get glyph");
|
|
@@ -256,7 +272,7 @@ static int
|
|
moveto(nsFT_CONST FT_Vector *aEndPt, void *aClosure)
|
|
{
|
|
FT2PT1_info *fti = (FT2PT1_info *)aClosure;
|
|
- FT_UShort upm = fti->face->units_per_EM;
|
|
+ FT_UShort upm = get_upm (fti->face);
|
|
PRBool rslt;
|
|
|
|
if (fti->elm_cnt == 0) {
|
|
@@ -293,7 +309,7 @@ static int
|
|
lineto(nsFT_CONST FT_Vector *aEndPt, void *aClosure)
|
|
{
|
|
FT2PT1_info *fti = (FT2PT1_info *)aClosure;
|
|
- FT_UShort upm = fti->face->units_per_EM;
|
|
+ FT_UShort upm = get_upm (fti->face);
|
|
|
|
if (toCS(upm, aEndPt->x) == fti->cur_x) {
|
|
fti->len += ecsi(&fti->buf, toCS(upm, aEndPt->y) - (int)fti->cur_y);
|
|
@@ -320,7 +336,7 @@ conicto(nsFT_CONST FT_Vector *aControlPt
|
|
void *aClosure)
|
|
{
|
|
FT2PT1_info *ftinfo = (FT2PT1_info *)aClosure;
|
|
- FT_UShort upm = ftinfo->face->units_per_EM;
|
|
+ FT_UShort upm = get_upm (ftinfo->face);
|
|
double ctl_x, ctl_y;
|
|
double cur_x, cur_y, x3, y3;
|
|
FT_Vector aControlPt1, aControlPt2;
|
|
@@ -353,7 +369,7 @@ cubicto(nsFT_CONST FT_Vector *aControlPt
|
|
nsFT_CONST FT_Vector *aEndPt, void *aClosure)
|
|
{
|
|
FT2PT1_info *ftinfo = (FT2PT1_info *)aClosure;
|
|
- FT_UShort upm = ftinfo->face->units_per_EM;
|
|
+ FT_UShort upm = get_upm (ftinfo->face);
|
|
double cur_x, cur_y, x1, y1, x2, y2, x3, y3;
|
|
|
|
cur_x = ftinfo->cur_x;
|
|
@@ -408,8 +424,55 @@ static FT_Outline_Funcs ft_outline_funcs
|
|
0
|
|
};
|
|
|
|
+
|
|
+static int
|
|
+trace_bitmap_glyph (FT_GlyphSlot slot, FT2PT1_info *fti)
|
|
+{
|
|
+ unsigned char *row, *byte_ptr, byte;
|
|
+ int rows, cols;
|
|
+ int x, y, bit_mask;
|
|
+ int upm, x_off, y_off, x_mult, y_mult;
|
|
+
|
|
+ upm = get_upm (slot->face);
|
|
+ x_off = slot->bitmap_left;
|
|
+ y_off = slot->bitmap_top;
|
|
+ x_mult = upm / slot->face->size->metrics.x_ppem;
|
|
+ y_mult = upm / slot->face->size->metrics.y_ppem;
|
|
+
|
|
+ switch (slot->bitmap.pixel_mode) {
|
|
+ case FT_PIXEL_MODE_MONO:
|
|
+
|
|
+ for (y = 0, row = slot->bitmap.buffer, rows = slot->bitmap.rows; rows; row += slot->bitmap.pitch, rows--, y++) {
|
|
+ for (x = 0, byte_ptr = row, cols = (slot->bitmap.width + 7) / 8; cols; byte_ptr++, cols--) {
|
|
+ byte = *byte_ptr;
|
|
+ for (bit_mask = 128; bit_mask && x < slot->bitmap.width; bit_mask >>= 1, x++) {
|
|
+ if (byte & bit_mask) {
|
|
+ FT_Vector p;
|
|
+ p.x = x_mult * (x_off + x);
|
|
+ p.y = y_mult * (y_off - y);
|
|
+ moveto(&p, (void *) fti);
|
|
+ p.x += x_mult;
|
|
+ lineto(&p, (void *) fti);
|
|
+ p.y += y_mult;
|
|
+ lineto(&p, (void *) fti);
|
|
+ p.x -= x_mult;
|
|
+ lineto(&p, (void *) fti);
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ break;
|
|
+
|
|
+ default:
|
|
+ return 1;
|
|
+ }
|
|
+
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+
|
|
FT_Error
|
|
-#ifdef MOZ_ENABLE_XFT
|
|
+#if defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
FT2GlyphToType1CharString(FT_Face aFace, PRUint32 aGlyphID,
|
|
int aWmode, int aLenIV, unsigned char *aBuf)
|
|
#else
|
|
@@ -423,7 +486,7 @@ FT2GlyphToType1CharString(nsIFreeType2 *
|
|
unsigned char *start = aBuf;
|
|
FT2PT1_info fti;
|
|
|
|
-#ifdef MOZ_ENABLE_XFT
|
|
+#if defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
FT_Error error = FT_Load_Glyph(aFace, aGlyphID, flags);
|
|
if (error) {
|
|
NS_ERROR("failed to load aGlyphID");
|
|
@@ -438,11 +501,6 @@ FT2GlyphToType1CharString(nsIFreeType2 *
|
|
#endif
|
|
slot = aFace->glyph;
|
|
|
|
- if (slot->format != ft_glyph_format_outline) {
|
|
- NS_ERROR("aGlyphID is not an outline glyph");
|
|
- return 1;
|
|
- }
|
|
-
|
|
#ifdef MOZ_ENABLE_FREETYPE2
|
|
fti.ft2 = aFt2;
|
|
#endif
|
|
@@ -456,18 +514,27 @@ FT2GlyphToType1CharString(nsIFreeType2 *
|
|
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;
|
|
- }
|
|
+
|
|
+ if (slot->format == ft_glyph_format_outline) {
|
|
+#if defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
+ 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;
|
|
- }
|
|
+ rv = aFt2->OutlineDecompose(&slot->outline, &ft_outline_funcs, &fti);
|
|
+ if (NS_FAILED(rv)) {
|
|
+ NS_ERROR("error decomposing aGlyphID");
|
|
+ }
|
|
#endif
|
|
+ } else if (slot->format == ft_glyph_format_bitmap) {
|
|
+ /* ok, it's a bitmap glyph. trace it! */
|
|
+ if (trace_bitmap_glyph (slot, &fti)) {
|
|
+ NS_ERROR("error tracing bitmap glyph");
|
|
+ }
|
|
+ } else {
|
|
+ NS_ERROR("aGlyphID has unhandled format");
|
|
+ }
|
|
|
|
if (fti.elm_cnt) {
|
|
fti.len += csc(&fti.buf, T1_CLOSEPATH);
|
|
@@ -491,28 +558,52 @@ FT2GlyphToType1CharString(nsIFreeType2 *
|
|
}
|
|
|
|
static PRBool
|
|
-#ifdef MOZ_ENABLE_XFT
|
|
+#if defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
outputType1SubFont(FT_Face aFace,
|
|
#else
|
|
outputType1SubFont(nsIFreeType2 *aFt2, FT_Face aFace,
|
|
#endif
|
|
- const nsAString &aCharIDs, const char *aFontName,
|
|
- int aWmode, int aLenIV, FILE *aFile);
|
|
+ nsValueArray *aGlyphs,
|
|
+ PRUint32 aOffset, PRUint32 aLen,
|
|
+ const char *aFontName,
|
|
+ int aWmode, int aLenIV, FILE *aFile);
|
|
|
|
nsresult
|
|
FT2ToType1FontName(FT_Face aFace, int aWmode, nsCString& aFontName)
|
|
{
|
|
+ // only hash the first 10 000 bytes of the font
|
|
+ int size = aFace->stream->size;
|
|
+ size = size > 10000 ? 10000 : size;
|
|
+
|
|
+ unsigned char *data;
|
|
+ if (aFace->stream->read) {
|
|
+ data = (unsigned char *) malloc (size);
|
|
+ aFace->stream->read (aFace->stream, 0, data, size);
|
|
+ } else {
|
|
+ data = aFace->stream->base;
|
|
+ }
|
|
+
|
|
+ unsigned int data_hash = 0;
|
|
+ int i;
|
|
+ for (i = 0; i < size; i++)
|
|
+ data_hash = (data_hash << 5) - data_hash + data[size];
|
|
+
|
|
+ if (aFace->stream->read)
|
|
+ free (data);
|
|
+
|
|
aFontName = aFace->family_name;
|
|
aFontName.AppendLiteral(".");
|
|
aFontName += aFace->style_name;
|
|
- aFontName += nsPrintfCString(".%ld.%d", aFace->face_index, aWmode ? 1 : 0);
|
|
+ aFontName += nsPrintfCString(".%ld.%d.%lx.%x", aFace->face_index, aWmode ? 1 : 0,
|
|
+ (long) aFace->stream->size, data_hash);
|
|
flattenName(aFontName);
|
|
+
|
|
return NS_OK;
|
|
}
|
|
|
|
// output a subsetted truetype font converted to multiple type 1 fonts
|
|
PRBool
|
|
-FT2SubsetToType1FontSet(FT_Face aFace, const nsString& aSubset,
|
|
+FT2SubsetToType1FontSet(FT_Face aFace, nsValueArray *aGlyphSubset,
|
|
int aWmode, FILE *aFile)
|
|
{
|
|
#ifdef MOZ_ENABLE_FREETYPE2
|
|
@@ -527,32 +618,35 @@ FT2SubsetToType1FontSet(FT_Face aFace, c
|
|
nsCAutoString fontNameBase;
|
|
FT2ToType1FontName(aFace, aWmode, fontNameBase);
|
|
PRUint32 i = 0;
|
|
- for (; i <= aSubset.Length() / 255 ; i++) {
|
|
+ for (; i <= aGlyphSubset->Count() / 255 ; i++) {
|
|
nsCAutoString fontName(fontNameBase);
|
|
fontName.AppendLiteral(".Set");
|
|
fontName.AppendInt(i);
|
|
-#ifdef MOZ_ENABLE_XFT
|
|
+#if defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
outputType1SubFont(aFace,
|
|
#else
|
|
outputType1SubFont(ft2, aFace,
|
|
#endif
|
|
- Substring(aSubset, i * 255, PR_MIN(255, aSubset.Length() - i * 255)),
|
|
- fontName.get(), aWmode, 4, aFile);
|
|
+ aGlyphSubset,
|
|
+ (i * 255), PR_MIN(255, aGlyphSubset->Count() - i * 255),
|
|
+ fontName.get(), aWmode, 4, aFile);
|
|
}
|
|
return PR_TRUE;
|
|
}
|
|
|
|
// output a type 1 font (with 255 characters or fewer)
|
|
static PRBool
|
|
-#ifdef MOZ_ENABLE_XFT
|
|
+#if defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
outputType1SubFont(FT_Face aFace,
|
|
#else
|
|
outputType1SubFont(nsIFreeType2 *aFt2, FT_Face aFace,
|
|
#endif
|
|
- const nsAString& aCharIDs, const char *aFontName,
|
|
- int aWmode, int aLenIV, FILE *aFile)
|
|
+ nsValueArray *aGlyphs,
|
|
+ PRUint32 aOffset, PRUint32 aLen,
|
|
+ const char *aFontName,
|
|
+ int aWmode, int aLenIV, FILE *aFile)
|
|
{
|
|
- FT_UShort upm = aFace->units_per_EM;
|
|
+ FT_UShort upm = get_upm (aFace);
|
|
|
|
fprintf(aFile, "%%%%BeginResource: font %s\n"
|
|
"%%!PS-AdobeFont-1.0-3.0 %s 1.0\n"
|
|
@@ -573,9 +667,13 @@ outputType1SubFont(nsIFreeType2 *aFt2, F
|
|
toCS(upm, aFace->bbox.xMax),
|
|
toCS(upm, aFace->bbox.yMax));
|
|
|
|
- nsString charIDstr(aCharIDs);
|
|
- PRUint32 len = aCharIDs.Length();
|
|
-
|
|
+ nsValueArray glyphs(PR_UINT16_MAX);
|
|
+ nsCStringArray glyphnames(PR_UINT16_MAX);
|
|
+ glyphs = *aGlyphs;
|
|
+
|
|
+ PRUint32 len = aLen;
|
|
+ PRUint32 i;
|
|
+
|
|
if (len < 10) {
|
|
// Add a small set of characters to the subset of the user
|
|
// defined font to produce to make sure the font ends up
|
|
@@ -584,25 +682,47 @@ outputType1SubFont(nsIFreeType2 *aFt2, F
|
|
// XXX : need to check if this is true of type 1 fonts as well.
|
|
// I suspect it's only the case of CID-keyed fonts (type 9) we used to
|
|
// generate.
|
|
- charIDstr.AppendLiteral("1234567890");
|
|
+ for (i = 1; i <= 10; i++) {
|
|
+ glyphs.AppendValue(i);
|
|
+ }
|
|
len += 10;
|
|
}
|
|
|
|
- const PRUnichar *charIDs = charIDstr.get();
|
|
-
|
|
- PRUint32 i;
|
|
+ FT_Int has_glyph_name;
|
|
+#if defined (MOZ_ENABLE_XFT) || defined (MOZ_ENABLE_PANGO)
|
|
+ has_glyph_name = FT_Has_PS_Glyph_Names(aFace);
|
|
+#else
|
|
+ has_glyph_name = aFt2->hasPSGlyphNames(aFace);
|
|
+#endif
|
|
|
|
// construct an Encoding vector : the 0th element
|
|
// is /.notdef
|
|
- fputs("/Encoding [\n/.notdef\n", aFile);
|
|
- for (i = 0; i < len; ++i) {
|
|
- fprintf(aFile, "/uni%04X", charIDs[i]);
|
|
- if (i % 8 == 7) fputc('\n', aFile);
|
|
+ fputs("/Encoding [\n/.notdef", aFile);
|
|
+ for (i = aOffset; i < aOffset + aLen; ++i) {
|
|
+ nsCString name;
|
|
+ char buffer[256];
|
|
+
|
|
+ if (glyphs.ValueAt(i) == 0) {
|
|
+ name = "/.notdef";
|
|
+ } else if (!has_glyph_name ||
|
|
+#if defined (MOZ_ENABLE_XFT) || defined (MOZ_ENABLE_PANGO)
|
|
+ FT_Get_Glyph_Name(aFace, glyphs.ValueAt(i), buffer, 255) != FT_Err_Ok
|
|
+#else
|
|
+ NS_FAILED(aFt2->getGlyphName(aFace, glyphs.ValueAt(i), buffer, 255))
|
|
+#endif
|
|
+ ) {
|
|
+ name = nsPrintfCString(256, "/idx%04X", glyphs.ValueAt(i));
|
|
+ } else {
|
|
+ name = nsPrintfCString(256, "/%s", buffer);
|
|
+ }
|
|
+ glyphnames.AppendCString(name);
|
|
+ fprintf(aFile, name.get());
|
|
+ if ((i-aOffset) % 8 == 6) fputc('\n', aFile);
|
|
}
|
|
|
|
- for (i = len; i < 255; ++i) {
|
|
+ for (i = PR_MAX (0, 255 - int(aLen)); i; --i) {
|
|
fputs("/.notdef", aFile);
|
|
- if (i % 8 == 7) fputc('\n', aFile);
|
|
+ if (i % 8 == 1) fputc('\n', aFile);
|
|
}
|
|
fputs("] def\n", aFile);
|
|
|
|
@@ -630,23 +750,21 @@ outputType1SubFont(nsIFreeType2 *aFt2, F
|
|
// get the maximum charstring length without actually filling up the buffer
|
|
PRInt32 charStringLen;
|
|
PRInt32 maxCharStringLen =
|
|
-#ifdef MOZ_ENABLE_XFT
|
|
+#if defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
FT2GlyphToType1CharString(aFace, 0, aWmode, aLenIV, nsnull);
|
|
#else
|
|
FT2GlyphToType1CharString(aFt2, aFace, 0, aWmode, aLenIV, nsnull);
|
|
#endif
|
|
|
|
- PRUint32 glyphID;
|
|
-
|
|
- for (i = 0; i < len; i++) {
|
|
-#ifdef MOZ_ENABLE_XFT
|
|
- glyphID = FT_Get_Char_Index(aFace, charIDs[i]);
|
|
+ for (i = aOffset; i < aOffset + aLen; i++) {
|
|
+#if defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
charStringLen =
|
|
- FT2GlyphToType1CharString(aFace, glyphID, aWmode, aLenIV, nsnull);
|
|
+ FT2GlyphToType1CharString(aFace, glyphs.ValueAt(i), aWmode, aLenIV,
|
|
+ nsnull);
|
|
#else
|
|
- aFt2->GetCharIndex(aFace, charIDs[i], &glyphID);
|
|
charStringLen =
|
|
- FT2GlyphToType1CharString(aFt2, aFace, glyphID, aWmode, aLenIV, nsnull);
|
|
+ FT2GlyphToType1CharString(aFt2, aFace, glyphs.ValueAt(i), aWmode, aLenIV,
|
|
+ nsnull);
|
|
#endif
|
|
|
|
if (charStringLen > maxCharStringLen)
|
|
@@ -666,7 +784,7 @@ outputType1SubFont(nsIFreeType2 *aFt2, F
|
|
len + 1).get());
|
|
|
|
// output the notdef glyph
|
|
-#ifdef MOZ_ENABLE_XFT
|
|
+#if defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
charStringLen = FT2GlyphToType1CharString(aFace, 0, aWmode, aLenIV,
|
|
charString.get());
|
|
#else
|
|
@@ -676,22 +794,20 @@ outputType1SubFont(nsIFreeType2 *aFt2, F
|
|
|
|
// enclose charString with "/.notdef RD ..... ND"
|
|
charStringOut(aFile, &pos, &key, NS_REINTERPRET_CAST(const char*, charString.get()),
|
|
- charStringLen, 0);
|
|
+ charStringLen, "/.notdef");
|
|
|
|
|
|
// output the charstrings for each glyph in this sub font
|
|
- for (i = 0; i < len; i++) {
|
|
-#ifdef MOZ_ENABLE_XFT
|
|
- glyphID = FT_Get_Char_Index(aFace, charIDs[i]);
|
|
- charStringLen = FT2GlyphToType1CharString(aFace, glyphID, aWmode,
|
|
+ for (i = aOffset; i < aOffset + aLen; i++) {
|
|
+#if defined(MOZ_ENABLE_XFT) || defined(MOZ_ENABLE_PANGO)
|
|
+ charStringLen = FT2GlyphToType1CharString(aFace, glyphs.ValueAt(i), aWmode,
|
|
aLenIV, charString.get());
|
|
#else
|
|
- aFt2->GetCharIndex(aFace, charIDs[i], &glyphID);
|
|
- charStringLen = FT2GlyphToType1CharString(aFt2, aFace, glyphID, aWmode,
|
|
- aLenIV, charString.get());
|
|
+ charStringLen = FT2GlyphToType1CharString(aFt2, aFace, glyphs.ValueAt(i),
|
|
+ aWmode, aLenIV, charString.get());
|
|
#endif
|
|
charStringOut(aFile, &pos, &key, NS_REINTERPRET_CAST(const char*, charString.get()),
|
|
- charStringLen, charIDs[i]);
|
|
+ charStringLen, glyphnames.CStringAt(i - aOffset)->get());
|
|
}
|
|
|
|
// wrap up the encrypted part of the font definition
|
|
@@ -753,15 +869,12 @@ void encryptAndHexOut(FILE *aFile, PRUin
|
|
|
|
/* static */
|
|
void charStringOut(FILE* aFile, PRUint32* aPos, PRUint16* aKey,
|
|
- const char *aStr, PRUint32 aLen, PRUnichar aId)
|
|
+ const char *aStr, PRUint32 aLen, const char *aGlyphName)
|
|
{
|
|
// use a local buffer instead of nsPrintfCString to avoid alloc.
|
|
char buf[30];
|
|
int oLen;
|
|
- if (aId == 0)
|
|
- oLen = PR_snprintf(buf, 30, "/.notdef %d RD ", aLen);
|
|
- else
|
|
- oLen = PR_snprintf(buf, 30, "/uni%04X %d RD ", aId, aLen);
|
|
+ oLen = PR_snprintf(buf, 30, "%s %d RD ", aGlyphName, aLen);
|
|
|
|
if (oLen >= 30) {
|
|
NS_WARNING("buffer size exceeded. charstring will be truncated");
|
|
Index: gfx/src/ps/nsType1.h
|
|
===================================================================
|
|
RCS file: /cvsroot/mozilla/gfx/src/ps/nsType1.h,v
|
|
retrieving revision 1.5
|
|
diff -u -p -d -r1.5 nsType1.h
|
|
--- gfx/src/ps/nsType1.h 4 Mar 2005 07:39:27 -0000 1.5
|
|
+++ gfx/src/ps/nsType1.h 23 Oct 2006 17:37:39 -0000
|
|
@@ -122,8 +122,9 @@ FT_Error FT2GlyphToType1CharString(nsIFr
|
|
|
|
class nsString;
|
|
class nsCString;
|
|
+class nsValueArray;
|
|
|
|
-PRBool FT2SubsetToType1FontSet(FT_Face aFace, const nsString& aSubset,
|
|
+PRBool FT2SubsetToType1FontSet(FT_Face aFace, nsValueArray *aGlyphSubset,
|
|
int aWmode, FILE *aFile);
|
|
nsresult FT2ToType1FontName(FT_Face aFace, int aWmode,
|
|
nsCString& aFontName);
|
|
Index: config/system-headers
|
|
===================================================================
|
|
--- config/system-headers 2006-10-26 12:21:39.000000000 -0400
|
|
+++ config/system-headers 2006-10-26 12:23:29.000000000 -0400
|
|
@@ -180,6 +180,7 @@
|
|
freetype/ftoutln.h
|
|
freetype/ttnameid.h
|
|
freetype/tttables.h
|
|
+freetype/t1tables.h
|
|
fribidi/fribidi.h
|
|
FSp_fopen.h
|
|
fstream.h
|
|
@@ -484,6 +485,7 @@
|
|
pango/pangofc-fontmap.h
|
|
pango/pango-fontmap.h
|
|
pango/pango.h
|
|
+pango/pangoft2.h
|
|
pango/pangoxft.h
|
|
pango/pangox.h
|
|
pango-types.h
|