Git-Url: 
http://git.frugalware.org/gitweb/gitweb.cgi?p=frugalware-current.git;a=commitdiff;h=5cc400b894017223722924fc1e5b3cf2dcb22915

commit 5cc400b894017223722924fc1e5b3cf2dcb22915
Author: James Buren <r...@frugalware.org>
Date:   Sat Sep 11 00:22:41 2010 -0500

cairo-1.8.10-3-i686
* implement lcd filter patch
* implement patch to force cairo to respect fontconfig settings
* release bump

diff --git a/source/xlib/cairo/FrugalBuild b/source/xlib/cairo/FrugalBuild
index 679cb9f..9e808f4 100644
--- a/source/xlib/cairo/FrugalBuild
+++ b/source/xlib/cairo/FrugalBuild
@@ -3,7 +3,7 @@

pkgname=cairo
pkgver=1.8.10
-pkgrel=2
+pkgrel=3
pkgdesc="A vector graphics library with cross-device output support"
url="http://cairographics.org";
depends=('glitz' 'libxrender>=0.9.4-3' 'fontconfig' 'libpng>=1.4.1' 
'libxcb>=1.3' 'libx11>=1.2.1' \
@@ -12,9 +12,13 @@ makedepends=('gtk-doc>=1.10' 'poppler-glib' 
'librsvg>=2.26.0-2')
groups=('xlib')
archs=('x86_64' 'i686' 'ppc')
up2date="lynx -dump 'http://cairographics.org/releases/?C=D;O=A'|grep -m1 
'/LATEST-cairo'|sed 's/.*ro-\(.*\).*/\1/'"
-source=($url/releases/$pkgname-$pkgver.tar.gz)
+source=($url/releases/$pkgname-$pkgver.tar.gz \
+        $pkgname-lcd-filter.patch             \
+       $pkgname-respect-fontconfig.patch)
options=('scriptlet')
Fconfopts="$Fconfopts --enable-glitz --enable-gtk-doc --enable-pdf --enable-ps 
--enable-xcb"
-sha1sums=('fd5e8ca82ff0e8542ea4c51612cad387f2a49df3')
+sha1sums=('fd5e8ca82ff0e8542ea4c51612cad387f2a49df3' \
+          'fdbf7b88ab3d51dec395a2fbe216000b7e379d1a' \
+          '76fdca5bf0a803a37869f725adbedd9f0691671d')

# optimization OK
diff --git a/source/xlib/cairo/cairo-lcd-filter.patch 
b/source/xlib/cairo/cairo-lcd-filter.patch
new file mode 100644
index 0000000..ad44426
--- /dev/null
+++ b/source/xlib/cairo/cairo-lcd-filter.patch
@@ -0,0 +1,1042 @@
+diff -urNad cairo-1.8.0~/src/cairo-font-options.c 
cairo-1.8.0/src/cairo-font-options.c
+--- cairo-1.8.0~/src/cairo-font-options.c      2008-09-25 22:30:14.000000000 
+0200
++++ cairo-1.8.0/src/cairo-font-options.c       2008-10-14 15:01:37.000000000 
+0200
+@@ -39,6 +39,7 @@
+ static const cairo_font_options_t _cairo_font_options_nil = {
+     CAIRO_ANTIALIAS_DEFAULT,
+     CAIRO_SUBPIXEL_ORDER_DEFAULT,
++    CAIRO_LCD_FILTER_DEFAULT,
+     CAIRO_HINT_STYLE_DEFAULT,
+     CAIRO_HINT_METRICS_DEFAULT
+ };
+@@ -54,6 +55,7 @@
+ {
+     options->antialias = CAIRO_ANTIALIAS_DEFAULT;
+     options->subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;
++    options->lcd_filter = CAIRO_LCD_FILTER_DEFAULT;
+     options->hint_style = CAIRO_HINT_STYLE_DEFAULT;
+     options->hint_metrics = CAIRO_HINT_METRICS_DEFAULT;
+ }
+@@ -64,6 +66,7 @@
+ {
+     options->antialias = other->antialias;
+     options->subpixel_order = other->subpixel_order;
++    options->lcd_filter = other->lcd_filter;
+     options->hint_style = other->hint_style;
+     options->hint_metrics = other->hint_metrics;
+ }
+@@ -189,6 +192,8 @@
+       options->antialias = other->antialias;
+     if (other->subpixel_order != CAIRO_SUBPIXEL_ORDER_DEFAULT)
+       options->subpixel_order = other->subpixel_order;
++    if (other->lcd_filter != CAIRO_LCD_FILTER_DEFAULT)
++      options->lcd_filter = other->lcd_filter;
+     if (other->hint_style != CAIRO_HINT_STYLE_DEFAULT)
+       options->hint_style = other->hint_style;
+     if (other->hint_metrics != CAIRO_HINT_METRICS_DEFAULT)
+@@ -221,6 +226,7 @@
+
+     return (options->antialias == other->antialias &&
+           options->subpixel_order == other->subpixel_order &&
++          options->lcd_filter == other->lcd_filter &&
+           options->hint_style == other->hint_style &&
+           options->hint_metrics == other->hint_metrics);
+ }
+@@ -246,7 +252,8 @@
+
+     return ((options->antialias) |
+           (options->subpixel_order << 4) |
+-          (options->hint_style << 8) |
++          (options->lcd_filter << 8) |
++          (options->hint_style << 12) |
+           (options->hint_metrics << 16));
+ }
+ slim_hidden_def (cairo_font_options_hash);
+@@ -328,6 +335,48 @@
+ }
+
+ /**
++ * _cairo_font_options_set_lcd_filter:
++ * @options: a #cairo_font_options_t
++ * @lcd_filter: the new LCD filter
++ *
++ * Sets the LCD filter for the font options object. The LCD filter
++ * specifies how pixels are filtered when rendered with an antialiasing
++ * mode of %CAIRO_ANTIALIAS_SUBPIXEL. See the documentation for
++ * #cairo_lcd_filter_t for full details.
++ *
++ * Since: 1.8
++ **/
++void
++_cairo_font_options_set_lcd_filter (cairo_font_options_t *options,
++                                  cairo_lcd_filter_t    lcd_filter)
++{
++    if (cairo_font_options_status (options))
++      return;
++
++    options->lcd_filter = lcd_filter;
++}
++
++/**
++ * _cairo_font_options_get_lcd_filter:
++ * @options: a #cairo_font_options_t
++ *
++ * Gets the LCD filter for the font options object.
++ * See the documentation for #cairo_lcd_filter_t for full details.
++ *
++ * Return value: the LCD filter for the font options object
++ *
++ * Since: 1.8
++ **/
++cairo_lcd_filter_t
++_cairo_font_options_get_lcd_filter (const cairo_font_options_t *options)
++{
++    if (cairo_font_options_status ((cairo_font_options_t *) options))
++      return CAIRO_LCD_FILTER_DEFAULT;
++
++    return options->lcd_filter;
++}
++
++/**
+  * cairo_font_options_set_hint_style:
+  * @options: a #cairo_font_options_t
+  * @hint_style: the new hint style
+diff -urNad cairo-1.8.0~/src/cairo-ft-font.c cairo-1.8.0/src/cairo-ft-font.c
+--- cairo-1.8.0~/src/cairo-ft-font.c   2008-09-25 22:28:24.000000000 +0200
++++ cairo-1.8.0/src/cairo-ft-font.c    2008-10-14 15:01:37.000000000 +0200
+@@ -57,6 +57,30 @@
+ #include FT_SYNTHESIS_H
+ #endif
+
++#if HAVE_FT_LIBRARY_SETLCDFILTER
++#include FT_LCD_FILTER_H
++#endif
++
++/* Fontconfig version older than 2.6 didn't have these options */
++#ifndef FC_LCD_FILTER
++#define FC_LCD_FILTER "lcdfilter"
++#endif
++/* Some Ubuntu versions defined FC_LCD_FILTER without defining the following 
*/
++#ifndef FC_LCD_NONE
++#define FC_LCD_NONE   0
++#define FC_LCD_DEFAULT        1
++#define FC_LCD_LIGHT  2
++#define FC_LCD_LEGACY 3
++#endif
++
++/* FreeType version older than 2.3.5(?) didn't have these options */
++#ifndef FT_LCD_FILTER_NONE
++#define FT_LCD_FILTER_NONE    0
++#define FT_LCD_FILTER_DEFAULT 1
++#define FT_LCD_FILTER_LIGHT   2
++#define FT_LCD_FILTER_LEGACY  16
++#endif
++
+ #define DOUBLE_TO_26_6(d) ((FT_F26Dot6)((d) * 64.0))
+ #define DOUBLE_FROM_26_6(t) ((double)(t) / 64.0)
+ #define DOUBLE_TO_16_16(d) ((FT_Fixed)((d) * 65536.0))
+@@ -737,23 +761,286 @@
+     return CAIRO_STATUS_SUCCESS;
+ }
+
+-/* Empirically-derived subpixel filtering values thanks to Keith
+- * Packard and libXft. */
+-static const int    filters[3][3] = {
+-    /* red */
+-#if 0
+-    {    65538*4/7,65538*2/7,65538*1/7 },
+-    /* green */
+-    {    65536*1/4, 65536*2/4, 65537*1/4 },
+-    /* blue */
+-    {    65538*1/7,65538*2/7,65538*4/7 },
++/* we sometimes need to convert the glyph bitmap in a FT_GlyphSlot
++ * into a different format. For example, we want to convert a
++ * FT_PIXEL_MODE_LCD or FT_PIXEL_MODE_LCD_V bitmap into a 32-bit
++ * ARGB or ABGR bitmap.
++ *
++ * this function prepares a target descriptor for this operation.
++ *
++ * input :: target bitmap descriptor. The function will set its
++ *          'width', 'rows' and 'pitch' fields, and only these
++ *
++ * slot  :: the glyph slot containing the source bitmap. this
++ *          function assumes that slot->format == FT_GLYPH_FORMAT_BITMAP
++ *
++ * mode  :: the requested final rendering mode. supported values are
++ *          MONO, NORMAL (i.e. gray), LCD and LCD_V
++ *
++ * the function returns the size in bytes of the corresponding buffer,
++ * it's up to the caller to allocate the corresponding memory block
++ * before calling _fill_xrender_bitmap
++ *
++ * it also returns -1 in case of error (e.g. incompatible arguments,
++ * like trying to convert a gray bitmap into a monochrome one)
++ */
++static int
++_compute_xrender_bitmap_size(FT_Bitmap      *target,
++                           FT_GlyphSlot    slot,
++                           FT_Render_Mode  mode)
++{
++    FT_Bitmap *ftbit;
++    int width, height, pitch;
++
++    if (slot->format != FT_GLYPH_FORMAT_BITMAP)
++      return -1;
++
++    /* compute the size of the final bitmap */
++    ftbit = &slot->bitmap;
++
++    width = ftbit->width;
++    height = ftbit->rows;
++    pitch = (width + 3) & ~3;
++
++    switch (ftbit->pixel_mode) {
++    case FT_PIXEL_MODE_MONO:
++      if (mode == FT_RENDER_MODE_MONO) {
++          pitch = (((width + 31) & ~31) >> 3);
++          break;
++      }
++      /* fall-through */
++
++    case FT_PIXEL_MODE_GRAY:
++      if (mode == FT_RENDER_MODE_LCD ||
++          mode == FT_RENDER_MODE_LCD_V)
++      {
++          /* each pixel is replicated into a 32-bit ARGB value */
++          pitch = width * 4;
++      }
++      break;
++
++    case FT_PIXEL_MODE_LCD:
++      if (mode != FT_RENDER_MODE_LCD)
++          return -1;
++
++      /* horz pixel triplets are packed into 32-bit ARGB values */
++      width /= 3;
++      pitch = width * 4;
++      break;
++
++    case FT_PIXEL_MODE_LCD_V:
++      if (mode != FT_RENDER_MODE_LCD_V)
++          return -1;
++
++      /* vert pixel triplets are packed into 32-bit ARGB values */
++      height /= 3;
++      pitch = width * 4;
++      break;
++
++    default:  /* unsupported source format */
++      return -1;
++    }
++
++    target->width = width;
++    target->rows = height;
++    target->pitch = pitch;
++    target->buffer = NULL;
++
++    return pitch * height;
++}
++
++/* this functions converts the glyph bitmap found in a FT_GlyphSlot
++ * into a different format (see _compute_xrender_bitmap_size)
++ *
++ * you should call this function after _compute_xrender_bitmap_size
++ *
++ * target :: target bitmap descriptor. Note that its 'buffer' pointer
++ *           must point to memory allocated by the caller
++ *
++ * slot   :: the glyph slot containing the source bitmap
++ *
++ * mode   :: the requested final rendering mode
++ *
++ * bgr    :: boolean, set if BGR or VBGR pixel ordering is needed
++ */
++static void
++_fill_xrender_bitmap(FT_Bitmap      *target,
++                   FT_GlyphSlot    slot,
++                   FT_Render_Mode  mode,
++                   int             bgr)
++{
++    FT_Bitmap *ftbit = &slot->bitmap;
++    unsigned char *srcLine = ftbit->buffer;
++    unsigned char *dstLine = target->buffer;
++    int src_pitch = ftbit->pitch;
++    int width = target->width;
++    int height = target->rows;
++    int pitch = target->pitch;
++    int subpixel;
++    int h;
++
++    subpixel = (mode == FT_RENDER_MODE_LCD ||
++              mode == FT_RENDER_MODE_LCD_V);
++
++    if (src_pitch < 0)
++      srcLine -= src_pitch * (ftbit->rows - 1);
++
++    target->pixel_mode = ftbit->pixel_mode;
++
++    switch (ftbit->pixel_mode) {
++    case FT_PIXEL_MODE_MONO:
++      if (subpixel) {
++          /* convert mono to ARGB32 values */
++
++          for (h = height; h > 0; h--, srcLine += src_pitch, dstLine += 
pitch) {
++              int x;
++
++              for (x = 0; x < width; x++) {
++                  if (srcLine[(x >> 3)] & (0x80 >> (x & 7)))
++                      ((unsigned int *) dstLine)[x] = 0xffffffffU;
++              }
++          }
++          target->pixel_mode = FT_PIXEL_MODE_LCD;
++
++      } else if (mode == FT_RENDER_MODE_NORMAL) {
++          /* convert mono to 8-bit gray */
++
++          for (h = height; h > 0; h--, srcLine += src_pitch, dstLine += 
pitch) {
++              int x;
++
++              for (x = 0; x < width; x++) {
++                  if (srcLine[(x >> 3)] & (0x80 >> (x & 7)))
++                      dstLine[x] = 0xff;
++              }
++          }
++          target->pixel_mode = FT_PIXEL_MODE_GRAY;
++
++      } else {
++          /* copy mono to mono */
++
++          int  bytes = (width + 7) >> 3;
++
++          for (h = height; h > 0; h--, srcLine += src_pitch, dstLine += pitch)
++              memcpy (dstLine, srcLine, bytes);
++      }
++      break;
++
++    case FT_PIXEL_MODE_GRAY:
++      if (subpixel) {
++          /* convert gray to ARGB32 values */
++
++          for (h = height; h > 0; h--, srcLine += src_pitch, dstLine += 
pitch) {
++              int x;
++              unsigned int *dst = (unsigned int *) dstLine;
++
++              for (x = 0; x < width; x++) {
++                  unsigned int pix = srcLine[x];
++
++                  pix |= (pix << 8);
++                  pix |= (pix << 16);
++
++                  dst[x] = pix;
++              }
++          }
++          target->pixel_mode = FT_PIXEL_MODE_LCD;
++        } else {
++            /* copy gray into gray */
++
++            for (h = height; h > 0; h--, srcLine += src_pitch, dstLine += 
pitch)
++                memcpy (dstLine, srcLine, width);
++        }
++        break;
++
++    case FT_PIXEL_MODE_LCD:
++      if (!bgr) {
++          /* convert horizontal RGB into ARGB32 */
++
++          for (h = height; h > 0; h--, srcLine += src_pitch, dstLine += 
pitch) {
++              int x;
++              unsigned char *src = srcLine;
++              unsigned int *dst = (unsigned int *) dstLine;
++
++              for (x = 0; x < width; x++, src += 3) {
++                  unsigned int  pix;
++
++                  pix = ((unsigned int)src[0] << 16) |
++                        ((unsigned int)src[1] <<  8) |
++                        ((unsigned int)src[2]      ) |
++                        ((unsigned int)src[1] << 24) ;
++
++                  dst[x] = pix;
++              }
++          }
++      } else {
++          /* convert horizontal BGR into ARGB32 */
++
++          for (h = height; h > 0; h--, srcLine += src_pitch, dstLine += 
pitch) {
++
++              int x;
++              unsigned char *src = srcLine;
++              unsigned int *dst = (unsigned int *) dstLine;
++
++              for (x = 0; x < width; x++, src += 3) {
++                  unsigned int  pix;
++
++                  pix = ((unsigned int)src[2] << 16) |
++                        ((unsigned int)src[1] <<  8) |
++                        ((unsigned int)src[0]      ) |
++                        ((unsigned int)src[1] << 24) ;
++
++                  dst[x] = pix;
++              }
++          }
++      }
++      break;
++
++    default:  /* FT_PIXEL_MODE_LCD_V */
++      /* convert vertical RGB into ARGB32 */
++      if (!bgr) {
++
++          for (h = height; h > 0; h--, srcLine += 3 * src_pitch, dstLine += 
pitch) {
++              int x;
++              unsigned char* src = srcLine;
++              unsigned int*  dst = (unsigned int *) dstLine;
++
++              for (x = 0; x < width; x++, src += 1) {
++                  unsigned int pix;
++#if 1
++                  pix = ((unsigned int)src[0]           << 16) |
++                        ((unsigned int)src[src_pitch]   <<  8) |
++                        ((unsigned int)src[src_pitch*2]      ) |
++                        0xFF000000 ;
++#else
++                  pix = ((unsigned int)src[0]           << 16) |
++                        ((unsigned int)src[src_pitch]   <<  8) |
++                        ((unsigned int)src[src_pitch*2]      ) |
++                        ((unsigned int)src[src_pitch]   << 24) ;
+ #endif
+-    {    65538*9/13,65538*3/13,65538*1/13 },
+-    /* green */
+-    {    65538*1/6, 65538*4/6, 65538*1/6 },
+-    /* blue */
+-    {    65538*1/13,65538*3/13,65538*9/13 },
+-};
++                  dst[x] = pix;
++              }
++          }
++      } else {
++
++          for (h = height; h > 0; h--, srcLine += 3*src_pitch, dstLine += 
pitch) {
++              int x;
++              unsigned char *src = srcLine;
++              unsigned int *dst = (unsigned int *) dstLine;
++
++              for (x = 0; x < width; x++, src += 1) {
++                  unsigned int  pix;
++
++                  pix = ((unsigned int)src[src_pitch * 2] << 16) |
++                        ((unsigned int)src[src_pitch]     <<  8) |
++                        ((unsigned int)src[0]                  ) |
++                        ((unsigned int)src[src_pitch]     << 24) ;
++
++                  dst[x] = pix;
++              }
++          }
++      }
++    }
++}
++
+
+ /* Fills in val->image with an image surface created from @bitmap
+  */
+@@ -766,7 +1053,7 @@
+     int width, height, stride;
+     unsigned char *data;
+     int format = CAIRO_FORMAT_A8;
+-    cairo_bool_t subpixel = FALSE;
++    cairo_image_surface_t *image;
+
+     width = bitmap->width;
+     height = bitmap->rows;
+@@ -823,11 +1110,7 @@
+     case FT_PIXEL_MODE_LCD:
+     case FT_PIXEL_MODE_LCD_V:
+     case FT_PIXEL_MODE_GRAY:
+-      switch (font_options->antialias) {
+-      case CAIRO_ANTIALIAS_DEFAULT:
+-      case CAIRO_ANTIALIAS_GRAY:
+-      case CAIRO_ANTIALIAS_NONE:
+-      default:
++        if (font_options->antialias != CAIRO_ANTIALIAS_SUBPIXEL) {
+           stride = bitmap->pitch;
+           if (own_buffer) {
+               data = bitmap->buffer;
+@@ -839,104 +1122,16 @@
+               memcpy (data, bitmap->buffer, stride * height);
+           }
+           format = CAIRO_FORMAT_A8;
+-          break;
+-      case CAIRO_ANTIALIAS_SUBPIXEL: {
+-          int             x, y;
+-          unsigned char   *in_line, *out_line, *in;
+-          unsigned int    *out;
+-          unsigned int    red, green, blue;
+-          int             rf, gf, bf;
+-          int             s;
+-          int             o, os;
+-          unsigned char   *data_rgba;
+-          unsigned int    width_rgba, stride_rgba;
+-          int             vmul = 1;
+-          int             hmul = 1;
++      } else {
++          /* if we get there, the  data from the source bitmap
++           * really comes from _fill_xrender_bitmap, and is
++           * made of 32-bit ARGB or ABGR values */
++          assert (own_buffer != 0);
++          assert (bitmap->pixel_mode != FT_PIXEL_MODE_GRAY);
+
+-          switch (font_options->subpixel_order) {
+-          case CAIRO_SUBPIXEL_ORDER_DEFAULT:
+-          case CAIRO_SUBPIXEL_ORDER_RGB:
+-          case CAIRO_SUBPIXEL_ORDER_BGR:
+-          default:
+-              width /= 3;
+-              hmul = 3;
+-              break;
+-          case CAIRO_SUBPIXEL_ORDER_VRGB:
+-          case CAIRO_SUBPIXEL_ORDER_VBGR:
+-              vmul = 3;
+-              height /= 3;
+-              break;
+-          }
+-          /*
+-           * Filter the glyph to soften the color fringes
+-           */
+-          width_rgba = width;
++          data = bitmap->buffer;
+           stride = bitmap->pitch;
+-          stride_rgba = (width_rgba * 4 + 3) & ~3;
+-          data_rgba = calloc (stride_rgba, height);
+-          if (data_rgba == NULL) {
+-              if (own_buffer)
+-                  free (bitmap->buffer);
+-              return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+-          }
+-
+-          os = 1;
+-          switch (font_options->subpixel_order) {
+-          case CAIRO_SUBPIXEL_ORDER_VRGB:
+-              os = stride;
+-          case CAIRO_SUBPIXEL_ORDER_DEFAULT:
+-          case CAIRO_SUBPIXEL_ORDER_RGB:
+-          default:
+-              rf = 0;
+-              gf = 1;
+-              bf = 2;
+-              break;
+-          case CAIRO_SUBPIXEL_ORDER_VBGR:
+-              os = stride;
+-          case CAIRO_SUBPIXEL_ORDER_BGR:
+-              bf = 0;
+-              gf = 1;
+-              rf = 2;
+-              break;
+-          }
+-          in_line = bitmap->buffer;
+-          out_line = data_rgba;
+-          for (y = 0; y < height; y++)
+-          {
+-              in = in_line;
+-              out = (unsigned int *) out_line;
+-              in_line += stride * vmul;
+-              out_line += stride_rgba;
+-              for (x = 0; x < width * hmul; x += hmul)
+-              {
+-                  red = green = blue = 0;
+-                  o = 0;
+-                  for (s = 0; s < 3; s++)
+-                  {
+-                      red += filters[rf][s]*in[x+o];
+-                      green += filters[gf][s]*in[x+o];
+-                      blue += filters[bf][s]*in[x+o];
+-                      o += os;
+-                  }
+-                  red = red / 65536;
+-                  green = green / 65536;
+-                  blue = blue / 65536;
+-                  *out++ = (green << 24) | (red << 16) | (green << 8) | blue;
+-              }
+-          }
+-
+-          /* Images here are stored in native format. The
+-           * backend must convert to its own format as needed
+-           */
+-
+-          if (own_buffer)
+-              free (bitmap->buffer);
+-          data = data_rgba;
+-          stride = stride_rgba;
+           format = CAIRO_FORMAT_ARGB32;
+-          subpixel = TRUE;
+-          break;
+-      }
+       }
+       break;
+     case FT_PIXEL_MODE_GRAY2:
+@@ -948,19 +1143,20 @@
+       return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+     }
+
+-    *surface = (cairo_image_surface_t *)
++    /* XXX */
++    *surface = image = (cairo_image_surface_t *)
+       cairo_image_surface_create_for_data (data,
+                                            format,
+                                            width, height, stride);
+-    if ((*surface)->base.status) {
++    if (image->base.status) {
+       free (data);
+       return (*surface)->base.status;
+     }
+
+-    if (subpixel)
+-      pixman_image_set_component_alpha ((*surface)->pixman_image, TRUE);
++    if (font_options->antialias == CAIRO_ANTIALIAS_SUBPIXEL)
++      pixman_image_set_component_alpha (image->pixman_image, TRUE);
+
+-    _cairo_image_surface_assume_ownership_of_data ((*surface));
++    _cairo_image_surface_assume_ownership_of_data (image);
+
+     return CAIRO_STATUS_SUCCESS;
+ }
+@@ -985,16 +1181,59 @@
+                      cairo_font_options_t      *font_options,
+                      cairo_image_surface_t    **surface)
+ {
++    int rgba = FC_RGBA_UNKNOWN;
++    int lcd_filter = FT_LCD_FILTER_LEGACY;
+     FT_GlyphSlot glyphslot = face->glyph;
+     FT_Outline *outline = &glyphslot->outline;
+     FT_Bitmap bitmap;
+     FT_BBox cbox;
+-    FT_Matrix matrix;
+-    int hmul = 1;
+-    int vmul = 1;
+-    unsigned int width, height, stride;
+-    cairo_bool_t subpixel = FALSE;
++    unsigned int width, height;
+     cairo_status_t status;
++    FT_Error fterror;
++    FT_Library library = glyphslot->library;
++    FT_Render_Mode render_mode = FT_RENDER_MODE_NORMAL;
++
++    switch (font_options->antialias) {
++    case CAIRO_ANTIALIAS_NONE:
++      render_mode = FT_RENDER_MODE_MONO;
++      break;
++
++    case CAIRO_ANTIALIAS_SUBPIXEL:
++      switch (font_options->subpixel_order) {
++          case CAIRO_SUBPIXEL_ORDER_DEFAULT:
++          case CAIRO_SUBPIXEL_ORDER_RGB:
++          case CAIRO_SUBPIXEL_ORDER_BGR:
++              render_mode = FT_RENDER_MODE_LCD;
++              break;
++
++          case CAIRO_SUBPIXEL_ORDER_VRGB:
++          case CAIRO_SUBPIXEL_ORDER_VBGR:
++              render_mode = FT_RENDER_MODE_LCD_V;
++              break;
++      }
++
++      switch (font_options->lcd_filter) {
++      case CAIRO_LCD_FILTER_NONE:
++          lcd_filter = FT_LCD_FILTER_NONE;
++          break;
++      case CAIRO_LCD_FILTER_DEFAULT:
++      case CAIRO_LCD_FILTER_INTRA_PIXEL:
++          lcd_filter = FT_LCD_FILTER_LEGACY;
++          break;
++      case CAIRO_LCD_FILTER_FIR3:
++          lcd_filter = FT_LCD_FILTER_LIGHT;
++          break;
++      case CAIRO_LCD_FILTER_FIR5:
++          lcd_filter = FT_LCD_FILTER_DEFAULT;
++          break;
++      }
++
++      break;
++
++    case CAIRO_ANTIALIAS_DEFAULT:
++    case CAIRO_ANTIALIAS_GRAY:
++      render_mode = FT_RENDER_MODE_NORMAL;
++    }
+
+     FT_Outline_Get_CBox (outline, &cbox);
+
+@@ -1005,20 +1244,21 @@
+
+     width = (unsigned int) ((cbox.xMax - cbox.xMin) >> 6);
+     height = (unsigned int) ((cbox.yMax - cbox.yMin) >> 6);
+-    stride = (width * hmul + 3) & ~3;
+
+     if (width * height == 0) {
+       cairo_format_t format;
+       /* Looks like fb handles zero-sized images just fine */
+-      switch (font_options->antialias) {
+-      case CAIRO_ANTIALIAS_NONE:
++      switch (render_mode) {
++      case FT_RENDER_MODE_MONO:
+           format = CAIRO_FORMAT_A1;
+           break;
+-      case CAIRO_ANTIALIAS_SUBPIXEL:
++      case FT_RENDER_MODE_LCD:
++      case FT_RENDER_MODE_LCD_V:
+           format= CAIRO_FORMAT_ARGB32;
+           break;
+-      case CAIRO_ANTIALIAS_DEFAULT:
+-      case CAIRO_ANTIALIAS_GRAY:
++      case FT_RENDER_MODE_LIGHT:
++      case FT_RENDER_MODE_NORMAL:
++      case FT_RENDER_MODE_MAX:
+       default:
+           format = CAIRO_FORMAT_A8;
+           break;
+@@ -1030,73 +1270,73 @@
+           return (*surface)->base.status;
+     } else  {
+
+-      matrix.xx = matrix.yy = 0x10000L;
+-      matrix.xy = matrix.yx = 0;
++      int bitmap_size;
+
+-      switch (font_options->antialias) {
+-      case CAIRO_ANTIALIAS_NONE:
+-          bitmap.pixel_mode = FT_PIXEL_MODE_MONO;
+-          bitmap.num_grays  = 1;
+-          stride = ((width + 31) & -32) >> 3;
+-          break;
+-      case CAIRO_ANTIALIAS_DEFAULT:
+-      case CAIRO_ANTIALIAS_GRAY:
+-          bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
+-          bitmap.num_grays  = 256;
+-          stride = (width + 3) & -4;
++      switch (render_mode) {
++      case FT_RENDER_MODE_LCD:
++          if (font_options->subpixel_order == CAIRO_SUBPIXEL_ORDER_BGR) {
++              rgba = FC_RGBA_BGR;
++          } else {
++              rgba = FC_RGBA_RGB;
++          }
+           break;
+-      case CAIRO_ANTIALIAS_SUBPIXEL:
+-          switch (font_options->subpixel_order) {
+-          case CAIRO_SUBPIXEL_ORDER_RGB:
+-          case CAIRO_SUBPIXEL_ORDER_BGR:
+-          case CAIRO_SUBPIXEL_ORDER_DEFAULT:
+-          default:
+-              matrix.xx *= 3;
+-              hmul = 3;
+-              subpixel = TRUE;
+-              break;
+-          case CAIRO_SUBPIXEL_ORDER_VRGB:
+-          case CAIRO_SUBPIXEL_ORDER_VBGR:
+-              matrix.yy *= 3;
+-              vmul = 3;
+-              subpixel = TRUE;
+-              break;
++      case FT_RENDER_MODE_LCD_V:
++          if (font_options->subpixel_order == CAIRO_SUBPIXEL_ORDER_VBGR) {
++              rgba = FC_RGBA_VBGR;
++          } else {
++              rgba = FC_RGBA_VRGB;
+           }
+-          FT_Outline_Transform (outline, &matrix);
+-
+-          bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
+-          bitmap.num_grays  = 256;
+-          stride = (width * hmul + 3) & -4;
++          break;
++      case FT_RENDER_MODE_MONO:
++      case FT_RENDER_MODE_LIGHT:
++      case FT_RENDER_MODE_NORMAL:
++      case FT_RENDER_MODE_MAX:
++      default:
++          break;
+       }
+
+-      bitmap.pitch = stride;
+-      bitmap.width = width * hmul;
+-      bitmap.rows = height * vmul;
+-      bitmap.buffer = calloc (stride, bitmap.rows);
+-      if (bitmap.buffer == NULL)
++#if HAVE_FT_LIBRARY_SETLCDFILTER
++      FT_Library_SetLcdFilter (library, lcd_filter);
++#endif
++
++      fterror = FT_Render_Glyph (face->glyph, render_mode);
++
++#if HAVE_FT_LIBRARY_SETLCDFILTER
++      FT_Library_SetLcdFilter (library, FT_LCD_FILTER_NONE);
++#endif
++
++      if (fterror != 0)
+           return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+
+-      FT_Outline_Translate (outline, -cbox.xMin*hmul, -cbox.yMin*vmul);
++      bitmap_size = _compute_xrender_bitmap_size (&bitmap,
++                                                  face->glyph,
++                                                  render_mode);
++      if (bitmap_size < 0)
++          return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+
+-      if (FT_Outline_Get_Bitmap (glyphslot->library, outline, &bitmap) != 0) {
+-          free (bitmap.buffer);
++      bitmap.buffer = calloc (1, bitmap_size);
++      if (bitmap.buffer == NULL)
+           return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+-      }
+
++      _fill_xrender_bitmap (&bitmap, face->glyph, render_mode,
++                            (rgba == FC_RGBA_BGR || rgba == FC_RGBA_VBGR));
++
++      /* Note:
++       * _get_bitmap_surface will free bitmap.buffer if there is an error
++       */
+       status = _get_bitmap_surface (&bitmap, TRUE, font_options, surface);
+       if (status)
+           return status;
+-    }
+
+-    /*
+-     * Note: the font's coordinate system is upside down from ours, so the
+-     * Y coordinate of the control box needs to be negated.  Moreover, device
+-     * offsets are position of glyph origin relative to top left while xMin
+-     * and yMax are offsets of top left relative to origin.  Another negation.
+-     */
+-    cairo_surface_set_device_offset (&(*surface)->base,
+-                                   floor (-(double) cbox.xMin / 64.0),
+-                                   floor (+(double) cbox.yMax / 64.0));
++      /* Note: the font's coordinate system is upside down from ours, so the
++       * Y coordinate of the control box needs to be negated.  Moreover, 
device
++       * offsets are position of glyph origin relative to top left while xMin
++       * and yMax are offsets of top left relative to origin.  Another 
negation.
++       */
++      cairo_surface_set_device_offset (&(*surface)->base,
++                                       (double)-glyphslot->bitmap_left,
++                                       (double)+glyphslot->bitmap_top);
++    }
+
+     return CAIRO_STATUS_SUCCESS;
+ }
+@@ -1316,6 +1556,7 @@
+
+     if (antialias) {
+       cairo_subpixel_order_t subpixel_order;
++      int lcd_filter;
+
+       /* disable hinting if requested */
+       if (FcPatternGetBool (pattern,
+@@ -1351,6 +1592,25 @@
+           ft_options.base.antialias = CAIRO_ANTIALIAS_SUBPIXEL;
+       }
+
++      if (FcPatternGetInteger (pattern,
++                               FC_LCD_FILTER, 0, &lcd_filter) == 
FcResultMatch)
++      {
++          switch (lcd_filter) {
++          case FC_LCD_NONE:
++              ft_options.base.lcd_filter = CAIRO_LCD_FILTER_NONE;
++              break;
++          case FC_LCD_DEFAULT:
++              ft_options.base.lcd_filter = CAIRO_LCD_FILTER_FIR5;
++              break;
++          case FC_LCD_LIGHT:
++              ft_options.base.lcd_filter = CAIRO_LCD_FILTER_FIR3;
++              break;
++          case FC_LCD_LEGACY:
++              ft_options.base.lcd_filter = CAIRO_LCD_FILTER_INTRA_PIXEL;
++              break;
++          }
++      }
++
+ #ifdef FC_HINT_STYLE
+       if (FcPatternGetInteger (pattern,
+                                FC_HINT_STYLE, 0, &hintstyle) != FcResultMatch)
+@@ -1451,6 +1711,12 @@
+     if (other->base.hint_style == CAIRO_HINT_STYLE_NONE)
+       options->base.hint_style = CAIRO_HINT_STYLE_NONE;
+
++    if (options->base.lcd_filter == CAIRO_LCD_FILTER_DEFAULT)
++      options->base.lcd_filter = other->base.lcd_filter;
++
++    if (other->base.lcd_filter == CAIRO_LCD_FILTER_NONE)
++      options->base.lcd_filter = CAIRO_LCD_FILTER_NONE;
++
+     if (options->base.antialias == CAIRO_ANTIALIAS_NONE) {
+       if (options->base.hint_style == CAIRO_HINT_STYLE_NONE)
+           load_flags |= FT_LOAD_NO_HINTING;
+@@ -1474,11 +1740,11 @@
+               case CAIRO_SUBPIXEL_ORDER_DEFAULT:
+               case CAIRO_SUBPIXEL_ORDER_RGB:
+               case CAIRO_SUBPIXEL_ORDER_BGR:
+-                  load_target |= FT_LOAD_TARGET_LCD;
++                  load_target = FT_LOAD_TARGET_LCD;
+                   break;
+               case CAIRO_SUBPIXEL_ORDER_VRGB:
+               case CAIRO_SUBPIXEL_ORDER_VBGR:
+-                  load_target |= FT_LOAD_TARGET_LCD_V;
++                  load_target = FT_LOAD_TARGET_LCD_V;
+               break;
+               }
+           }
+@@ -2421,6 +2687,34 @@
+       }
+     }
+
++    if (options->lcd_filter != CAIRO_LCD_FILTER_DEFAULT)
++    {
++      if (FcPatternGet (pattern, FC_LCD_FILTER, 0, &v) == FcResultNoMatch)
++      {
++          int lcd_filter;
++
++          switch (options->lcd_filter) {
++          case CAIRO_LCD_FILTER_NONE:
++              lcd_filter = FT_LCD_FILTER_NONE;
++              break;
++          case CAIRO_LCD_FILTER_DEFAULT:
++          case CAIRO_LCD_FILTER_INTRA_PIXEL:
++              lcd_filter = FT_LCD_FILTER_LEGACY;
++              break;
++          case CAIRO_LCD_FILTER_FIR3:
++              lcd_filter = FT_LCD_FILTER_LIGHT;
++              break;
++          default:
++          case CAIRO_LCD_FILTER_FIR5:
++              lcd_filter = FT_LCD_FILTER_DEFAULT;
++              break;
++          }
++
++          if (! FcPatternAddInteger (pattern, FC_LCD_FILTER, lcd_filter))
++              return _cairo_error (CAIRO_STATUS_NO_MEMORY);
++      }
++    }
++
+     if (options->hint_style != CAIRO_HINT_STYLE_DEFAULT)
+     {
+       if (FcPatternGet (pattern, FC_HINTING, 0, &v) == FcResultNoMatch)
+diff -urNad cairo-1.8.0~/src/cairo-surface.c cairo-1.8.0/src/cairo-surface.c
+--- cairo-1.8.0~/src/cairo-surface.c   2008-09-25 22:28:56.000000000 +0200
++++ cairo-1.8.0/src/cairo-surface.c    2008-10-14 15:01:37.000000000 +0200
+@@ -73,6 +73,7 @@
+     FALSE,                            /* has_font_options */  \
+     { CAIRO_ANTIALIAS_DEFAULT,                /* antialias */         \
+       CAIRO_SUBPIXEL_ORDER_DEFAULT,   /* subpixel_order */    \
++      CAIRO_LCD_FILTER_DEFAULT,               /* lcd_filter */        \
+       CAIRO_HINT_STYLE_DEFAULT,               /* hint_style */        \
+       CAIRO_HINT_METRICS_DEFAULT      /* hint_metrics */      \
+     }                                 /* font_options */      \
+diff -urNad cairo-1.8.0~/src/cairo-types-private.h 
cairo-1.8.0/src/cairo-types-private.h
+--- cairo-1.8.0~/src/cairo-types-private.h     2008-09-25 22:29:06.000000000 
+0200
++++ cairo-1.8.0/src/cairo-types-private.h      2008-10-14 15:01:37.000000000 
+0200
+@@ -113,9 +113,35 @@
+     cairo_bool_t is_snapshot;
+ };
+
++
++/**
++ * cairo_lcd_filter_t:
++ * @CAIRO_LCD_FILTER_DEFAULT: Use the default LCD filter for
++ *   font backend and target device
++ * @CAIRO_LCD_FILTER_NONE: Do not perform LCD filtering
++ * @CAIRO_LCD_FILTER_INTRA_PIXEL: Intra-pixel filter
++ * @CAIRO_LCD_FILTER_FIR3: FIR filter with a 3x3 kernel
++ * @CAIRO_LCD_FILTER_FIR5: FIR filter with a 5x5 kernel
++ *
++ * The LCD filter specifies the low-pass filter applied to LCD-optimized
++ * bitmaps generated with an antialiasing mode of %CAIRO_ANTIALIAS_SUBPIXEL.
++ *
++ * Note: This API was temporarily made available in the public
++ * interface during the 1.7.x development series, but was made private
++ * before 1.8.
++ **/
++typedef enum _cairo_lcd_filter {
++    CAIRO_LCD_FILTER_DEFAULT,
++    CAIRO_LCD_FILTER_NONE,
++    CAIRO_LCD_FILTER_INTRA_PIXEL,
++    CAIRO_LCD_FILTER_FIR3,
++    CAIRO_LCD_FILTER_FIR5
++} cairo_lcd_filter_t;
++
+ struct _cairo_font_options {
+     cairo_antialias_t antialias;
+     cairo_subpixel_order_t subpixel_order;
++    cairo_lcd_filter_t lcd_filter;
+     cairo_hint_style_t hint_style;
+     cairo_hint_metrics_t hint_metrics;
+ };
+diff -urNad cairo-1.8.0~/src/cairo-xlib-screen.c 
cairo-1.8.0/src/cairo-xlib-screen.c
+--- cairo-1.8.0~/src/cairo-xlib-screen.c       2008-09-25 22:29:39.000000000 
+0200
++++ cairo-1.8.0/src/cairo-xlib-screen.c        2008-10-14 15:01:37.000000000 
+0200
+@@ -150,13 +150,22 @@
+     cairo_bool_t xft_antialias;
+     int xft_hintstyle;
+     int xft_rgba;
++    int xft_lcdfilter;
+     cairo_antialias_t antialias;
+     cairo_subpixel_order_t subpixel_order;
++    cairo_lcd_filter_t lcd_filter;
+     cairo_hint_style_t hint_style;
+
+     if (!get_boolean_default (dpy, "antialias", &xft_antialias))
+       xft_antialias = TRUE;
+
++    if (!get_integer_default (dpy, "lcdfilter", &xft_lcdfilter)) {
++      /* -1 is an non-existant Fontconfig constant used to differentiate
++       * the case when no lcdfilter property is available.
++       */
++      xft_lcdfilter = -1;
++    }
++
+     if (!get_boolean_default (dpy, "hinting", &xft_hinting))
+       xft_hinting = TRUE;
+
+@@ -239,6 +248,24 @@
+       subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;
+     }
+
++    switch (xft_lcdfilter) {
++    case FC_LCD_NONE:
++      lcd_filter = CAIRO_LCD_FILTER_NONE;
++      break;
++    case FC_LCD_DEFAULT:
++      lcd_filter = CAIRO_LCD_FILTER_FIR5;
++      break;
++    case FC_LCD_LIGHT:
++      lcd_filter = CAIRO_LCD_FILTER_FIR3;
++      break;
++    case FC_LCD_LEGACY:
++      lcd_filter = CAIRO_LCD_FILTER_INTRA_PIXEL;
++      break;
++    default:
++      lcd_filter = CAIRO_LCD_FILTER_DEFAULT;
++      break;
++    }
++
+     if (xft_antialias) {
+       if (subpixel_order == CAIRO_SUBPIXEL_ORDER_DEFAULT)
+           antialias = CAIRO_ANTIALIAS_GRAY;
+@@ -251,6 +278,7 @@
+     cairo_font_options_set_hint_style (&info->font_options, hint_style);
+     cairo_font_options_set_antialias (&info->font_options, antialias);
+     cairo_font_options_set_subpixel_order (&info->font_options, 
subpixel_order);
++    _cairo_font_options_set_lcd_filter (&info->font_options, lcd_filter);
+     cairo_font_options_set_hint_metrics (&info->font_options, 
CAIRO_HINT_METRICS_ON);
+ }
+
+diff -urNad cairo-1.8.0~/src/cairoint.h cairo-1.8.0/src/cairoint.h
+--- cairo-1.8.0~/src/cairoint.h        2008-09-26 00:56:48.000000000 +0200
++++ cairo-1.8.0/src/cairoint.h 2008-10-14 15:01:37.000000000 +0200
+@@ -1336,6 +1336,13 @@
+ _cairo_font_options_init_copy (cairo_font_options_t           *options,
+                              const cairo_font_options_t       *other);
+
++cairo_private void
++_cairo_font_options_set_lcd_filter (cairo_font_options_t   *options,
++                                 cairo_lcd_filter_t  lcd_filter);
++
++cairo_private cairo_lcd_filter_t
++_cairo_font_options_get_lcd_filter (const cairo_font_options_t *options);
++
+ /* cairo-hull.c */
+ cairo_private cairo_status_t
+ _cairo_hull_compute (cairo_pen_vertex_t *vertices, int *num_vertices);
diff --git a/source/xlib/cairo/cairo-respect-fontconfig.patch 
b/source/xlib/cairo/cairo-respect-fontconfig.patch
new file mode 100644
index 0000000..3bb8b8f
--- /dev/null
+++ b/source/xlib/cairo/cairo-respect-fontconfig.patch
@@ -0,0 +1,21 @@
+diff -Nur cairo-1.8.6.orig/src/cairo-ft-font.c cairo-1.8.6/src/cairo-ft-font.c
+--- cairo-1.8.6.orig/src/cairo-ft-font.c       2008-12-12 20:48:04.000000000 
+0800
++++ cairo-1.8.6/src/cairo-ft-font.c    2009-02-20 14:56:57.000000000 +0800
+@@ -1448,8 +1448,15 @@
+     if (options->base.hint_style == CAIRO_HINT_STYLE_DEFAULT)
+       options->base.hint_style = other->base.hint_style;
+
+-    if (other->base.hint_style == CAIRO_HINT_STYLE_NONE)
+-      options->base.hint_style = CAIRO_HINT_STYLE_NONE;
++    //if (other->base.hint_style == CAIRO_HINT_STYLE_NONE)
++      //options->base.hint_style = CAIRO_HINT_STYLE_NONE;
++
++      if (other->base.hint_style == CAIRO_HINT_STYLE_NONE ||
++              other->base.hint_style == CAIRO_HINT_STYLE_SLIGHT ||
++              other->base.hint_style == CAIRO_HINT_STYLE_MEDIUM ||
++              other->base.hint_style == CAIRO_HINT_STYLE_FULL) {
++      options->base.hint_style = other->base.hint_style;
++      }
+
+     if (options->base.antialias == CAIRO_ANTIALIAS_NONE) {
+       if (options->base.hint_style == CAIRO_HINT_STYLE_NONE)
_______________________________________________
Frugalware-git mailing list
Frugalware-git@frugalware.org
http://frugalware.org/mailman/listinfo/frugalware-git

Reply via email to