logo

etc_portage

Unnamed repository; edit this file 'description' to name the repository. git clone https://hacktivis.me/git/etc_portage.git

1.patch (21699B)

    

  1. From 7808631e7a9a605d5fe7a1077129c658d9ec47fc Mon Sep 17 00:00:00 2001
  2. From: Maxime Coste <mawww@kakoune.org>
  3. Date: Tue, 22 Oct 2019 22:46:49 +1100
  4. Subject: [PATCH] Add support for BGRA glyphs display and scaling
  6. Display is done using an XRender Picture, as XRender
  7. glyphs are incompatible with BGRA rendering due to
  8. their use of the glyph bitmap as a mask.
  10. Scaling is done by averaging all relevant pixel, which gives
  11. much better result than nearest pixel sampling while staying
  12. simple enough and not too computationally expensive.
  14. This enables color emoji rendering support.
  16. Fixes: #6
  18. Signed-off-by: Maxime Coste <mawww@kakoune.org>
  19. ---
  20.  src/xftfreetype.c |  18 ++++-
  21.  src/xftglyphs.c   | 200 ++++++++++++++++++++++++++++++++++++++++++----
  22.  src/xftint.h      |   2 +
  23.  src/xftrender.c   | 168 ++++++++++++++++++++++++--------------
  24.  4 files changed, 307 insertions(+), 81 deletions(-)
  26. diff --git a/src/xftfreetype.c b/src/xftfreetype.c
  27. index a3b8332..a639a03 100644
  28. --- a/src/xftfreetype.c
  29. +++ b/src/xftfreetype.c
  30. @@ -514,7 +514,7 @@ XftFontInfoFill (Display *dpy, _Xconst FcPattern *pattern, XftFontInfo *fi)
  31.      /*
  32.       * Compute glyph load flags
  33.       */
  34. -    fi->load_flags = FT_LOAD_DEFAULT;
  35. +    fi->load_flags = FT_LOAD_DEFAULT | FT_LOAD_COLOR;
  36.  
  37.  #ifndef XFT_EMBEDDED_BITMAP
  38.  #define XFT_EMBEDDED_BITMAP "embeddedbitmap"
  39. @@ -766,6 +766,7 @@ XftFontOpenInfo (Display	*dpy,
  40.      FcChar32		hash_value;
  41.      FcChar32		rehash_value;
  42.      FcBool		antialias;
  43. +    FcBool		color;
  44.      int			max_glyph_memory;
  45.      int			alloc_size;
  46.      int			ascent, descent, height;
  47. @@ -822,12 +823,16 @@ XftFontOpenInfo (Display	*dpy,
  48.      if (!(face->face_flags & FT_FACE_FLAG_SCALABLE))
  49.  	antialias = FcFalse;
  50.  
  51. +    color = FT_HAS_COLOR(face) ? FcTrue : FcFalse;
  52. +
  53.      /*
  54.       * Find the appropriate picture format
  55.       */
  56.      if (fi->render)
  57.      {
  58. -	if (antialias)
  59. +	if (color)
  60. +	    format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
  61. +	else if (antialias)
  62.  	{
  63.  	    switch (fi->rgba) {
  64.  	    case FC_RGBA_RGB:
  65. @@ -842,9 +847,7 @@ XftFontOpenInfo (Display	*dpy,
  66.  	    }
  67.  	}
  68.  	else
  69. -	{
  70.  	    format = XRenderFindStandardFormat (dpy, PictStandardA1);
  71. -	}
  72.  
  73.  	if (!format)
  74.  	    goto bail2;
  75. @@ -959,6 +962,13 @@ XftFontOpenInfo (Display	*dpy,
  76.       * which doesn't happen in XftFontInfoFill
  77.       */
  78.      font->info.antialias = antialias;
  79. +
  80. +    /*
  81. +     * Set color value, which is only known once the
  82. +     * font was loaded
  83. +     */
  84. +    font->info.color = color;
  85. +
  86.      /*
  87.       * bump XftFile reference count
  88.       */
  89. diff --git a/src/xftglyphs.c b/src/xftglyphs.c
  90. index 4b5fb82..af2e3c1 100644
  91. --- a/src/xftglyphs.c
  92. +++ b/src/xftglyphs.c
  93. @@ -26,6 +26,8 @@
  94.  
  95.  #include FT_SYNTHESIS_H
  96.  
  97. +#include FT_GLYPH_H
  98. +
  99.  /*
  100.   * Validate the memory info for a font
  101.   */
  102. @@ -78,9 +80,11 @@ _XftFontValidateMemory (Display *dpy, XftFont *public)
  103.  static int
  104.  _compute_xrender_bitmap_size( FT_Bitmap*	target,
  105.  			      FT_GlyphSlot	slot,
  106. -			      FT_Render_Mode	mode )
  107. +			      FT_Render_Mode	mode,
  108. +			      FT_Matrix*        matrix )
  109.  {
  110.      FT_Bitmap*	ftbit;
  111. +    FT_Vector	vector;
  112.      int		width, height, pitch;
  113.  
  114.      if ( slot->format != FT_GLYPH_FORMAT_BITMAP )
  115. @@ -88,9 +92,18 @@ _compute_xrender_bitmap_size( FT_Bitmap*	target,
  116.  
  117.      // compute the size of the final bitmap
  118.      ftbit = &slot->bitmap;
  119. -
  120.      width = ftbit->width;
  121.      height = ftbit->rows;
  122. +
  123. +    if ( matrix && mode == FT_RENDER_MODE_NORMAL )
  124. +    {
  125. +	vector.x = ftbit->width;
  126. +	vector.y = ftbit->rows;
  127. +	FT_Vector_Transform(&vector, matrix);
  128. +
  129. +	width = vector.x;
  130. +	height = vector.y;
  131. +    }
  132.      pitch = (width+3) & ~3;
  133.  
  134.      switch ( ftbit->pixel_mode )
  135. @@ -112,6 +125,10 @@ _compute_xrender_bitmap_size( FT_Bitmap*	target,
  136.  	}
  137.  	break;
  138.  
  139. +    case FT_PIXEL_MODE_BGRA:
  140. +	pitch = width * 4;
  141. +	break;
  142. +
  143.      case FT_PIXEL_MODE_LCD:
  144.  	if ( mode != FT_RENDER_MODE_LCD )
  145.  	    return -1;
  146. @@ -142,6 +159,105 @@ _compute_xrender_bitmap_size( FT_Bitmap*	target,
  147.      return pitch * height;
  148.  }
  149.  
  150. +/* this functions converts the glyph bitmap found in a FT_GlyphSlot
  151. + * into a different format while scaling by applying the given matrix
  152. + * (see _compute_xrender_bitmap_size)
  153. + *
  154. + * you should call this function after _compute_xrender_bitmap_size
  155. + *
  156. + * target :: target bitmap descriptor. Note that its 'buffer' pointer
  157. + *           must point to memory allocated by the caller
  158. + *
  159. + * source :: the source bitmap descriptor
  160. + *
  161. + * matrix :: the scaling matrix to apply
  162. + */
  163. +static void
  164. +_scaled_fill_xrender_bitmap( FT_Bitmap*	target,
  165. +		             FT_Bitmap* source,
  166. +                             const FT_Matrix* matrix )
  167. +{
  168. +    unsigned char*	src_buf	  = source->buffer;
  169. +    unsigned char*	dst_line  = target->buffer;
  170. +    int			src_pitch = source->pitch;
  171. +    int			width     = target->width;
  172. +    int			height    = target->rows;
  173. +    int			pitch     = target->pitch;
  174. +    int			h;
  175. +    FT_Vector		vector;
  176. +    FT_Matrix		inverse	  = *matrix;
  177. +    int			sampling_width;
  178. +    int			sampling_height;
  179. +    int			sample_count;
  180. +
  181. +    if ( src_pitch < 0 )
  182. +	src_buf -= src_pitch*(source->rows-1);
  183. +
  184. +    FT_Matrix_Invert(&inverse);
  185. +
  186. +    /* compute how many source pixels a target pixel spans */
  187. +    vector.x = 1;
  188. +    vector.y = 1;
  189. +    FT_Vector_Transform(&vector, &inverse);
  190. +    sampling_width = vector.x / 2;
  191. +    sampling_height = vector.y / 2;
  192. +    sample_count = (2 * sampling_width + 1) * (2 * sampling_height + 1);
  193. +
  194. +    for	( h = height; h	> 0; h--, dst_line += pitch )
  195. +    {
  196. +	int x;
  197. +
  198. +	for ( x	= 0; x < width;	x++ )
  199. +	{
  200. +	    unsigned char* src;
  201. +
  202. +#define CLAMP(x, min, max) ((x) < (min) ? (min) : ((x) > (max) ? (max) : (x)))
  203. +
  204. +            /* compute target pixel location in source space */
  205. +	    vector.x = (x            * 0x10000) + 0x10000 / 2;
  206. +	    vector.y = ((height - h) * 0x10000) + 0x10000 / 2;
  207. +	    FT_Vector_Transform(&vector, &inverse);
  208. +	    vector.x = CLAMP(FT_RoundFix(vector.x) / 0x10000, 0, source->width - 1);
  209. +	    vector.y = CLAMP(FT_RoundFix(vector.y) / 0x10000, 0, source->rows  - 1);
  210. +
  211. +	    switch ( source->pixel_mode	)
  212. +	    {
  213. +	    case FT_PIXEL_MODE_MONO: /* convert mono to 8-bit gray, scale using nearest pixel */
  214. +		src = src_buf + (vector.y * src_pitch);
  215. +		if ( src[(vector.x >> 3)] & (0x80 >> (vector.x & 7)) )
  216. +		    dst_line[x] = 0xff;
  217. +		break;
  218. +
  219. +	    case FT_PIXEL_MODE_GRAY: /* scale using nearest pixel */
  220. +		src = src_buf + (vector.y * src_pitch);
  221. +		dst_line[x] = src[vector.x];
  222. +		break;
  223. +
  224. +	    case FT_PIXEL_MODE_BGRA: /* scale by averaging all relevant source pixels, keep BGRA format */
  225. +	    {
  226. +		int sample_x, sample_y;
  227. +		int bgra[4] = {};
  228. +		for (sample_y = - sampling_height; sample_y < sampling_height + 1; ++sample_y)
  229. +		{
  230. +		    int src_y = CLAMP(vector.y + sample_y, 0, source->rows - 1);
  231. +		    src = src_buf + (src_y * src_pitch);
  232. +		    for (sample_x = - sampling_width; sample_x < sampling_width + 1; ++sample_x)
  233. +		    {
  234. +			int src_x = CLAMP(vector.x + sample_x, 0, source->width - 1);
  235. +			for (int i = 0; i < 4; ++i)
  236. +			    bgra[i] += src[src_x * 4 + i];
  237. +		    }
  238. +		}
  239. +
  240. +		for (int i = 0; i < 4; ++i)
  241. +		    dst_line[4 * x + i] = bgra[i] / sample_count;
  242. +		break;
  243. +	    }
  244. +	    }
  245. +	}
  246. +    }
  247. +}
  248. +
  249.  /* this functions converts the glyph bitmap found in a FT_GlyphSlot
  250.   * into a different format (see _compute_xrender_bitmap_size)
  251.   *
  252. @@ -244,6 +360,11 @@ _fill_xrender_bitmap( FT_Bitmap*	target,
  253.  	    }
  254.  	    break;
  255.  
  256. +	case FT_PIXEL_MODE_BGRA: /* Preserve BGRA format */
  257. +	    for ( h = height; h > 0; h--, srcLine += src_pitch, dstLine += pitch )
  258. +		memcpy( dstLine, srcLine, width * 4 );
  259. +	    break;
  260. +
  261.  	case FT_PIXEL_MODE_LCD:
  262.  	    if ( !bgr )
  263.  	    {
  264. @@ -365,6 +486,8 @@ XftFontLoadGlyphs (Display	    *dpy,
  265.      FT_Vector	    vector;
  266.      FT_Face	    face;
  267.      FT_Render_Mode  mode = FT_RENDER_MODE_MONO;
  268. +    FcBool	    transform;
  269. +    FcBool	    glyph_transform;
  270.  
  271.      if (!info)
  272.  	return;
  273. @@ -374,6 +497,8 @@ XftFontLoadGlyphs (Display	    *dpy,
  274.      if (!face)
  275.  	return;
  276.  
  277. +    if (font->info.color)
  278. +        mode = FT_RENDER_MODE_NORMAL;
  279.      if (font->info.antialias)
  280.      {
  281.  	switch (font->info.rgba) {
  282. @@ -390,6 +515,8 @@ XftFontLoadGlyphs (Display	    *dpy,
  283.  	}
  284.      }
  285.  
  286. +    transform = font->info.transform && mode != FT_RENDER_MODE_MONO;
  287. +
  288.      while (nglyph--)
  289.      {
  290.  	glyphindex = *glyphs++;
  291. @@ -440,7 +567,7 @@ XftFontLoadGlyphs (Display	    *dpy,
  292.  	/*
  293.  	 * Compute glyph metrics from FreeType information
  294.  	 */
  295. -	if(font->info.transform && glyphslot->format != FT_GLYPH_FORMAT_BITMAP)
  296. +	if (transform)
  297.  	{
  298.  	    /*
  299.  	     * calculate the true width by transforming all four corners.
  300. @@ -487,7 +614,7 @@ XftFontLoadGlyphs (Display	    *dpy,
  301.  	 * Clip charcell glyphs to the bounding box
  302.  	 * XXX transformed?
  303.  	 */
  304. -	if (font->info.spacing >= FC_CHARCELL && !font->info.transform)
  305. +	if (font->info.spacing >= FC_CHARCELL && !transform)
  306.  	{
  307.  	    if (font->info.load_flags & FT_LOAD_VERTICAL_LAYOUT)
  308.  	    {
  309. @@ -519,18 +646,20 @@ XftFontLoadGlyphs (Display	    *dpy,
  310.  	    }
  311.  	}
  312.  
  313. +	glyph_transform = transform;
  314.  	if ( glyphslot->format != FT_GLYPH_FORMAT_BITMAP )
  315.  	{
  316.  	    error = FT_Render_Glyph( face->glyph, mode );
  317.  	    if (error)
  318.  		continue;
  319. +	    glyph_transform = False;
  320.  	}
  321.  
  322.  	FT_Library_SetLcdFilter( _XftFTlibrary, FT_LCD_FILTER_NONE );
  323.  
  324.  	if (font->info.spacing >= FC_MONO)
  325.  	{
  326. -	    if (font->info.transform)
  327. +	    if (transform)
  328.  	    {
  329.  		if (font->info.load_flags & FT_LOAD_VERTICAL_LAYOUT)
  330.  		{
  331. @@ -613,14 +742,27 @@ XftFontLoadGlyphs (Display	    *dpy,
  332.  	    }
  333.  	}
  334.  
  335. -	size = _compute_xrender_bitmap_size( &local, glyphslot, mode );
  336. +	size = _compute_xrender_bitmap_size( &local, glyphslot, mode, glyph_transform ? &font->info.matrix : NULL );
  337.  	if ( size < 0 )
  338.  	    continue;
  339.  
  340.  	xftg->metrics.width  = local.width;
  341.  	xftg->metrics.height = local.rows;
  342. -	xftg->metrics.x      = - glyphslot->bitmap_left;
  343. -	xftg->metrics.y      =   glyphslot->bitmap_top;
  344. +	if (transform)
  345. +	{
  346. +	    vector.x = - glyphslot->bitmap_left;
  347. +	    vector.y =   glyphslot->bitmap_top;
  348. +
  349. +	    FT_Vector_Transform(&vector, &font->info.matrix);
  350. +
  351. +	    xftg->metrics.x = vector.x;
  352. +	    xftg->metrics.y = vector.y;
  353. +	}
  354. +	else
  355. +	{
  356. +	    xftg->metrics.x = - glyphslot->bitmap_left;
  357. +	    xftg->metrics.y =   glyphslot->bitmap_top;
  358. +	}
  359.  
  360.  	/*
  361.  	 * If the glyph is relatively large (> 1% of server memory),
  362. @@ -645,9 +787,12 @@ XftFontLoadGlyphs (Display	    *dpy,
  363.  
  364.  	local.buffer = bufBitmap;
  365.  
  366. -	_fill_xrender_bitmap( &local, glyphslot, mode,
  367. -			      (font->info.rgba == FC_RGBA_BGR ||
  368. -			       font->info.rgba == FC_RGBA_VBGR ) );
  369. +        if (mode == FT_RENDER_MODE_NORMAL && glyph_transform)
  370. +            _scaled_fill_xrender_bitmap(&local, &glyphslot->bitmap, &font->info.matrix);
  371. +        else
  372. +	    _fill_xrender_bitmap( &local, glyphslot, mode,
  373. +			          (font->info.rgba == FC_RGBA_BGR ||
  374. +			           font->info.rgba == FC_RGBA_VBGR ) );
  375.  
  376.  	/*
  377.  	 * Copy or convert into local buffer.
  378. @@ -662,6 +807,7 @@ XftFontLoadGlyphs (Display	    *dpy,
  379.  	 */
  380.  	glyph = (Glyph) glyphindex;
  381.  
  382. +	xftg->picture = 0;
  383.  	xftg->glyph_memory = size + sizeof (XftGlyph);
  384.  	if (font->format)
  385.  	{
  386. @@ -685,15 +831,35 @@ XftFontLoadGlyphs (Display	    *dpy,
  387.  		    }
  388.  		}
  389.  	    }
  390. -	    else if ( mode != FT_RENDER_MODE_NORMAL )
  391. +	    else if (glyphslot->bitmap.pixel_mode == FT_PIXEL_MODE_BGRA || mode != FT_RENDER_MODE_NORMAL)
  392.  	    {
  393.  		/* invert ARGB <=> BGRA */
  394.  		if (ImageByteOrder (dpy) != XftNativeByteOrder ())
  395.  		    XftSwapCARD32 ((CARD32 *) bufBitmap, size >> 2);
  396.  	    }
  397. -	    XRenderAddGlyphs (dpy, font->glyphset, &glyph,
  398. -			      &xftg->metrics, 1,
  399. -			      (char *) bufBitmap, size);
  400. +
  401. +	    if (glyphslot->bitmap.pixel_mode == FT_PIXEL_MODE_BGRA)
  402. +	    {
  403. +		Pixmap pixmap = XCreatePixmap(dpy, DefaultRootWindow(dpy), local.width, local.rows, 32);
  404. +		GC gc = XCreateGC(dpy, pixmap, 0, NULL);
  405. +		XImage image = {
  406. +		    local.width, local.rows, 0, ZPixmap, (char *)bufBitmap,
  407. +		    dpy->byte_order, dpy->bitmap_unit, dpy->bitmap_bit_order, 32,
  408. +		    32, local.width * 4 - local.pitch, 32,
  409. +		    0, 0, 0
  410. +		};
  411. +
  412. +		XInitImage(&image);
  413. +		XPutImage(dpy, pixmap, gc, &image, 0, 0, 0, 0, local.width, local.rows);
  414. +		xftg->picture = XRenderCreatePicture(dpy, pixmap, font->format, 0, NULL);
  415. +
  416. +		XFreeGC(dpy, gc);
  417. +		XFreePixmap(dpy, pixmap);
  418. +	    }
  419. +	    else
  420. +		XRenderAddGlyphs (dpy, font->glyphset, &glyph,
  421. +				  &xftg->metrics, 1,
  422. +				  (char *) bufBitmap, size);
  423.  	}
  424.  	else
  425.  	{
  426. @@ -744,7 +910,9 @@ XftFontUnloadGlyphs (Display		*dpy,
  427.  	{
  428.  	    if (font->format)
  429.  	    {
  430. -		if (font->glyphset)
  431. +		if (xftg->picture)
  432. +		    XRenderFreePicture(dpy, xftg->picture);
  433. +		else if (font->glyphset)
  434.  		{
  435.  		    glyphBuf[nused++] = (Glyph) glyphindex;
  436.  		    if (nused == sizeof (glyphBuf) / sizeof (glyphBuf[0]))
  437. diff --git a/src/xftint.h b/src/xftint.h
  438. index c06ac3c..b263520 100644
  439. --- a/src/xftint.h
  440. +++ b/src/xftint.h
  441. @@ -85,6 +85,7 @@ typedef struct _XftGlyph {
  442.      XGlyphInfo	    metrics;
  443.      void	    *bitmap;
  444.      unsigned long   glyph_memory;
  445. +    Picture         picture;
  446.  } XftGlyph;
  447.  
  448.  /*
  449. @@ -134,6 +135,7 @@ struct _XftFontInfo {
  450.      FT_F26Dot6		xsize, ysize;	/* pixel size */
  451.      FcBool		antialias;	/* doing antialiasing */
  452.      FcBool		embolden;	/* force emboldening */
  453. +    FcBool		color;		/* contains color glyphs */
  454.      int			rgba;		/* subpixel order */
  455.      int			lcd_filter;	/* lcd filter */
  456.      FT_Matrix		matrix;		/* glyph transformation matrix */
  457. diff --git a/src/xftrender.c b/src/xftrender.c
  458. index b280c03..9a789cb 100644
  459. --- a/src/xftrender.c
  460. +++ b/src/xftrender.c
  461. @@ -25,6 +25,35 @@
  462.  #define NUM_LOCAL	1024
  463.  #define NUM_ELT_LOCAL	128
  464.  
  465. +/*
  466. + * Dispatch glyph drawing to the correct XRenderCompositeString function
  467. + */
  468. +static void
  469. +_XftCompositeString (Display *dpy, int op, Picture src, Picture dst, XRenderPictFormat* format, GlyphSet glyphset, int srcx, int srcy, int dstx, int dsty, int charwidth, unsigned int* chars, int nchars)
  470. +{
  471. +    if (nchars == 0)
  472. +        return;
  473. +
  474. +    switch (charwidth) {
  475. +    case 1:
  476. +    default:
  477. +	XRenderCompositeString8 (dpy, op,
  478. +				 src, dst, format, glyphset,
  479. +				 srcx, srcy, dstx, dsty, (char*)chars, nchars);
  480. +	break;
  481. +    case 2:
  482. +	XRenderCompositeString16(dpy, op,
  483. +				 src, dst, format, glyphset,
  484. +				 srcx, srcy, dstx, dsty, (unsigned short*)chars, nchars);
  485. +	break;
  486. +    case 4:
  487. +	XRenderCompositeString32(dpy, op,
  488. +				 src, dst, format, glyphset,
  489. +				 srcx, srcy, dstx, dsty, (unsigned int*)chars, nchars);
  490. +	break;
  491. +    }
  492. +}
  493. +
  494.  /*
  495.   * Use the Render extension to draw the glyphs
  496.   */
  497. @@ -43,12 +72,14 @@ XftGlyphRender (Display		*dpy,
  498.  		int		nglyphs)
  499.  {
  500.      XftFontInt	    *font = (XftFontInt *) pub;
  501. -    int		    i;
  502. +    int		    i, j;
  503.      FT_UInt	    missing[XFT_NMISSING];
  504.      int		    nmissing;
  505.      FT_UInt	    g, max;
  506.      int		    size, width;
  507. +    int		    dstx, dsty;
  508.      Glyph	    wire;
  509. +    XftGlyph*       glyph;
  510.      char	    *char8;
  511.      unsigned short  *char16;
  512.      unsigned int    *char32;
  513. @@ -100,43 +131,75 @@ XftGlyphRender (Display		*dpy,
  514.  	if (!chars)
  515.  	    goto bail1;
  516.      }
  517. +    dstx = x;
  518. +    dsty = y;
  519.      char8 = (char *) chars;
  520.      char16 = (unsigned short *) chars;
  521.      char32 = (unsigned int *) chars;
  522. -    for (i = 0; i < nglyphs; i++)
  523. +    for (i = 0, j = 0; i < nglyphs; i++)
  524.      {
  525.  	wire = (Glyph) glyphs[i];
  526.  	if (wire >= font->num_glyphs || !font->glyphs[wire])
  527.  	    wire = 0;
  528. -	switch (width) {
  529. -	case 1: char8[i] = (char) wire; break;
  530. -	case 2: char16[i] = (unsigned short) wire; break;
  531. -	case 4: char32[i] = (unsigned long) wire; break;
  532. +        glyph = font->glyphs[wire];
  533. +	if (glyph->picture)
  534. +	{
  535. +	    _XftCompositeString(dpy, op, src, dst, font->format, font->glyphset, srcx, srcy, x, y, width, chars, j);
  536. +	    XRenderComposite(dpy, PictOpOver, glyph->picture, None, dst, 0, 0, 0, 0, dstx, dsty - glyph->metrics.y, glyph->metrics.width, glyph->metrics.height);
  537. +	    x = dstx = dstx + glyph->metrics.xOff;
  538. +	    x = dsty = dsty + glyph->metrics.yOff;
  539. +	    j = 0;
  540. +	}
  541. +	else
  542. +	{
  543. +	    switch (width) {
  544. +	    case 1: char8[j] = (char) wire; break;
  545. +	    case 2: char16[j] = (unsigned short) wire; break;
  546. +	    case 4: char32[j] = (unsigned long) wire; break;
  547. +	    }
  548. +	    dstx += glyph->metrics.xOff;
  549. +	    dsty += glyph->metrics.yOff;
  550. +	    ++j;
  551.  	}
  552.      }
  553. -    switch (width) {
  554. +    _XftCompositeString(dpy, op, src, dst, font->format, font->glyphset, srcx, srcy, x, y, width, chars, j);
  555. +    if (chars != char_local)
  556. +	free (chars);
  557. +bail1:
  558. +    if (glyphs_loaded)
  559. +	_XftFontManageMemory (dpy, pub);
  560. +}
  561. +
  562. +/*
  563. + * Dispatch glyph drawing to the correct XRenderCompositeText function
  564. + */
  565. +static void
  566. +_XftCompositeText (Display *dpy, int op, Picture src, Picture dst, XRenderPictFormat* format, int srcx, int srcy, int dstx, int dsty, int eltwidth, XGlyphElt8* elts, int nelt)
  567. +{
  568. +    if (nelt == 0)
  569. +        return;
  570. +
  571. +    switch (eltwidth) {
  572.      case 1:
  573.      default:
  574. -	XRenderCompositeString8 (dpy, op,
  575. -				 src, dst, font->format, font->glyphset,
  576. -				 srcx, srcy, x, y, char8, nglyphs);
  577. +	XRenderCompositeText8 (dpy, op,
  578. +			       src, dst, format,
  579. +			       srcx, srcy, dstx, dsty,
  580. +	                       (XGlyphElt8*)elts, nelt);
  581.  	break;
  582.      case 2:
  583. -	XRenderCompositeString16(dpy, op,
  584. -				 src, dst, font->format, font->glyphset,
  585. -				 srcx, srcy, x, y, char16, nglyphs);
  586. +	XRenderCompositeText16(dpy, op,
  587. +			       src, dst, format,
  588. +			       srcx, srcy, dstx, dsty,
  589. +	                       (XGlyphElt16*)elts, nelt);
  590.  	break;
  591.      case 4:
  592. -	XRenderCompositeString32(dpy, op,
  593. -				 src, dst, font->format, font->glyphset,
  594. -				 srcx, srcy, x, y, char32, nglyphs);
  595. +	XRenderCompositeText32(dpy, op,
  596. +			       src, dst, format,
  597. +			       srcx, srcy, dstx, dsty,
  598. +	                       (XGlyphElt32*)elts, nelt);
  599.  	break;
  600.      }
  601. -    if (chars != char_local)
  602. -	free (chars);
  603. -bail1:
  604. -    if (glyphs_loaded)
  605. -	_XftFontManageMemory (dpy, pub);
  606.  }
  607.  
  608.  _X_EXPORT void
  609. @@ -251,9 +314,10 @@ XftGlyphSpecRender (Display		    *dpy,
  610.  	    g = 0;
  611.  	/*
  612.  	 * check to see if the glyph is placed where it would
  613. -	 * fall using the normal spacing
  614. +	 * fall using the normal spacing and if it would render
  615. +	 * as a XRender glyph
  616.  	 */
  617. -	if ((glyph = font->glyphs[g]))
  618. +	if ((glyph = font->glyphs[g]) && !glyph->picture)
  619.  	{
  620.  	    if (x != glyphs[i].x || y != glyphs[i].y)
  621.  	    {
  622. @@ -267,7 +331,7 @@ XftGlyphSpecRender (Display		    *dpy,
  623.      }
  624.  
  625.      elts = elts_local;
  626. -    if (nelt > NUM_ELT_LOCAL)
  627. +    if (!font->info.color && nelt > NUM_ELT_LOCAL)
  628.      {
  629.  	elts = malloc (nelt * sizeof (XGlyphElt8));
  630.  	if (!elts)
  631. @@ -275,7 +339,7 @@ XftGlyphSpecRender (Display		    *dpy,
  632.      }
  633.  
  634.      /*
  635. -     * Generate the list of glyph elts
  636. +     * Generate the list of glyph elts or render color glyphs
  637.       */
  638.      nelt = 0;
  639.      x = y = 0;
  640. @@ -289,6 +353,11 @@ XftGlyphSpecRender (Display		    *dpy,
  641.  	    g = 0;
  642.  	if ((glyph = font->glyphs[g]))
  643.  	{
  644. +	    if (glyph->picture)
  645. +	    {
  646. +                XRenderComposite(dpy, PictOpOver, glyph->picture, None, dst, 0, 0, 0, 0, glyphs[i].x, glyphs[i].y - glyph->metrics.y, glyph->metrics.width, glyph->metrics.height);
  647. +                continue;
  648. +	    }
  649.  	    if (!i || x != glyphs[i].x || y != glyphs[i].y)
  650.  	    {
  651.  		if (n)
  652. @@ -320,23 +389,9 @@ XftGlyphSpecRender (Display		    *dpy,
  653.  	elts[nelt].nchars = n;
  654.  	nelt++;
  655.      }
  656. -    switch (width) {
  657. -    case 1:
  658. -	XRenderCompositeText8 (dpy, op, src, dst, font->format,
  659. -			       srcx, srcy, glyphs[0].x, glyphs[0].y,
  660. -			       elts, nelt);
  661. -	break;
  662. -    case 2:
  663. -	XRenderCompositeText16 (dpy, op, src, dst, font->format,
  664. -				srcx, srcy, glyphs[0].x, glyphs[0].y,
  665. -				(XGlyphElt16 *) elts, nelt);
  666. -	break;
  667. -    case 4:
  668. -	XRenderCompositeText32 (dpy, op, src, dst, font->format,
  669. -				srcx, srcy, glyphs[0].x, glyphs[0].y,
  670. -				(XGlyphElt32 *) elts, nelt);
  671. -	break;
  672. -    }
  673. +    _XftCompositeText(dpy, op, src, dst, font->format,
  674. +		      srcx, srcy, glyphs[0].x, glyphs[0].y,
  675. +		      width, elts, nelt);
  676.  
  677.      if (elts != elts_local)
  678.  	free (elts);
  679. @@ -535,7 +590,7 @@ XftGlyphFontSpecRender (Display			    *dpy,
  680.  	 * check to see if the glyph is placed where it would
  681.  	 * fall using the normal spacing
  682.  	 */
  683. -	if ((glyph = font->glyphs[g]))
  684. +	if ((glyph = font->glyphs[g]) && !glyph->picture)
  685.  	{
  686.  	    if (pub != prevPublic || x != glyphs[i].x || y != glyphs[i].y)
  687.  	    {
  688. @@ -560,7 +615,7 @@ XftGlyphFontSpecRender (Display			    *dpy,
  689.      }
  690.  
  691.      /*
  692. -     * Generate the list of glyph elts
  693. +     * Generate the list of glyph elts and render color glyphs
  694.       */
  695.      nelt = 0;
  696.      x = y = 0;
  697. @@ -578,6 +633,11 @@ XftGlyphFontSpecRender (Display			    *dpy,
  698.  	    g = 0;
  699.  	if ((glyph = font->glyphs[g]))
  700.  	{
  701. +	    if (glyph->picture)
  702. +	    {
  703. +                XRenderComposite(dpy, PictOpOver, glyph->picture, None, dst, 0, 0, 0, 0, glyphs[i].x, glyphs[i].y - glyph->metrics.y, glyph->metrics.width, glyph->metrics.height);
  704. +                continue;
  705. +	    }
  706.  	    if (!i || pub != prevPublic || x != glyphs[i].x || y != glyphs[i].y)
  707.  	    {
  708.  		if (n)
  709. @@ -610,23 +670,9 @@ XftGlyphFontSpecRender (Display			    *dpy,
  710.  	elts[nelt].nchars = n;
  711.  	nelt++;
  712.      }
  713. -    switch (width) {
  714. -    case 1:
  715. -	XRenderCompositeText8 (dpy, op, src, dst, format,
  716. -			       srcx, srcy, glyphs[0].x, glyphs[0].y,
  717. -			       elts, nelt);
  718. -	break;
  719. -    case 2:
  720. -	XRenderCompositeText16 (dpy, op, src, dst, format,
  721. -				srcx, srcy, glyphs[0].x, glyphs[0].y,
  722. -				(XGlyphElt16 *) elts, nelt);
  723. -	break;
  724. -    case 4:
  725. -	XRenderCompositeText32 (dpy, op, src, dst, format,
  726. -				srcx, srcy, glyphs[0].x, glyphs[0].y,
  727. -				(XGlyphElt32 *) elts, nelt);
  728. -	break;
  729. -    }
  730. +    _XftCompositeText(dpy, op, src, dst, format,
  731. +		      srcx, srcy, glyphs[0].x, glyphs[0].y,
  732. +		      width, elts, nelt);
  733.  
  734.      if (elts != elts_local)
  735.  	free (elts);
  736. -- 
  737. 2.24.1