diff options
Diffstat (limited to 'libXft')
32 files changed, 9744 insertions, 0 deletions
diff --git a/libXft/.gitignore b/libXft/.gitignore new file mode 100644 index 000000000..467810868 --- /dev/null +++ b/libXft/.gitignore @@ -0,0 +1,78 @@ +# +# X.Org module default exclusion patterns +# The next section if for module specific patterns +# +# Do not edit the following section +# GNU Build System (Autotools) +aclocal.m4 +autom4te.cache/ +autoscan.log +ChangeLog +compile +config.guess +config.h +config.h.in +config.log +config-ml.in +config.py +config.status +config.status.lineno +config.sub +configure +configure.scan +depcomp +.deps/ +INSTALL +install-sh +.libs/ +libtool +libtool.m4 +ltmain.sh +lt~obsolete.m4 +ltoptions.m4 +ltsugar.m4 +ltversion.m4 +Makefile +Makefile.in +mdate-sh +missing +mkinstalldirs +*.pc +py-compile +stamp-h? +symlink-tree +texinfo.tex +ylwrap + +# Do not edit the following section +# Edit Compile Debug Document Distribute +*~ +*.[0-9] +*.[0-9]x +*.bak +*.bin +core +*.dll +*.exe +*-ISO*.bdf +*-JIS*.bdf +*-KOI8*.bdf +*.kld +*.ko +*.ko.cmd +*.lai +*.l[oa] +*.[oa] +*.obj +*.patch +*.so +*.pcf.gz +*.pdb +*.tar.bz2 +*.tar.gz +# +# Add & Override patterns for libXft +# +# Edit the following section as needed +# For example, !report.pc overrides *.pc. See 'man gitignore' +# diff --git a/libXft/AUTHORS b/libXft/AUTHORS new file mode 100644 index 000000000..2fe754d23 --- /dev/null +++ b/libXft/AUTHORS @@ -0,0 +1,10 @@ +Keith Packard, of SuSE and HP + +Automake work by Noah Levitt +Frank Giessler - OS/2 +Jungshik Shin - UTF-16 api's +Ralf Habacker, Suhaib Siddiqi - Cygwin port +Marc La France - Sun port +David Dawes - bug fixes, maintenance. + +Our apologies if we've overlooked someone. diff --git a/libXft/COPYING b/libXft/COPYING new file mode 100644 index 000000000..e506314ae --- /dev/null +++ b/libXft/COPYING @@ -0,0 +1,21 @@ + +Copyright © 2001,2003 Keith Packard + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name of Keith Packard not be used in +advertising or publicity pertaining to distribution of the software without +specific, written prior permission. Keith Packard makes no +representations about the suitability of this software for any purpose. It +is provided "as is" without express or implied warranty. + +KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + diff --git a/libXft/Makefile.am b/libXft/Makefile.am new file mode 100644 index 000000000..aeacfe6f5 --- /dev/null +++ b/libXft/Makefile.am @@ -0,0 +1,37 @@ +# +# Copyright © 2003 Keith Packard, Noah Levitt +# +# Permission to use, copy, modify, distribute, and sell this software and its +# documentation for any purpose is hereby granted without fee, provided that +# the above copyright notice appear in all copies and that both that +# copyright notice and this permission notice appear in supporting +# documentation, and that the name of Keith Packard not be used in +# advertising or publicity pertaining to distribution of the software without +# specific, written prior permission. Keith Packard makes no +# representations about the suitability of this software for any purpose. It +# is provided "as is" without express or implied warranty. +# +# KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +# EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR +# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +# DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +# TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +# PERFORMANCE OF THIS SOFTWARE. + +SUBDIRS = man src + +pkgconfigdir = $(libdir)/pkgconfig +pkgconfig_DATA = xft.pc + +MAINTAINERCLEANFILES = ChangeLog INSTALL + +.PHONY: ChangeLog INSTALL + +INSTALL: + $(INSTALL_CMD) + +ChangeLog: + $(CHANGELOG_CMD) + +dist-hook: ChangeLog INSTALL diff --git a/libXft/NEWS b/libXft/NEWS new file mode 100644 index 000000000..01e6dbe28 --- /dev/null +++ b/libXft/NEWS @@ -0,0 +1,61 @@ + Xft + X FreeType library + Version 2.2.0 + 2010-10-29 + +Xft version 2.1 is the first stand alone release of Xft, a library that +connects X applications with the FreeType font rasterization library. Xft +uses fontconfig to locate fonts so it has no configuration files. + +Version 2.2.0 + +Dropped xft-config, now that pkg-config is well established. + +Version 2.1.14 + +Added fake bold support (#1579, Novell #38202/223682). + +Version 2.1.13 + +Fix hashing in 64-bit versions. Register objects with freetype. +Fix XftDrawRect when Render not supported. + +Version 2.1.12 + +Fix exporting of XftNameUnparse function. + +Version 2.1.9 + +Stop exporting unnecessary symbols. + +Version 2.1.7 + +Change FC_CHARCELL and FC_MONO interpretation. FC_MONO no longer clips +glyphs to charcell, you must specify FC_CHARCELL for that. + +Add support for FT_GlyphSlot_Embolden where it exists (which it usually +doesn't). + +Avoid crashing when using FT_Face objects. + +Version 2.1.6 + +Deal with broken FreeType 2.1.7 BDF/PCF loaders by trying both y_ppem/x_ppem +and width/height values. + +Version 2.1.5 + +Left some #warnings from testing in the 2.1.4 release. Spin again. + +Version 2.1.4 + +Work with older versions of Fontconfig by using various pattern elements +only when defined. + +Version 2.1.3 + +Change Freetype includes to new syntax. + +Search for nearest bitmap for bitmap-only fonts. + +Support fontconfig 2.2 release which doesn't include FC_HINT_STYLE. diff --git a/libXft/README b/libXft/README new file mode 100644 index 000000000..b1097eb44 --- /dev/null +++ b/libXft/README @@ -0,0 +1,52 @@ + Xft + X FreeType library + +Xft version 2.1 is the first stand alone release of Xft, a library that +connects X applications with the FreeType font rasterization library. Xft +uses fontconfig to locate fonts so it has no configuration files. + +Before building Xft you will need to have installed: + freetype http://freetype.org/ + fontconfig http://fontconfig.org/ + libX11, libXext, & libXrender http://x.org/ + +All questions regarding this software should be directed at the +Xorg mailing list: + + http://lists.freedesktop.org/mailman/listinfo/xorg + +Please submit bug reports to the Xorg bugzilla: + + https://bugs.freedesktop.org/enter_bug.cgi?product=xorg + +The master development code repository can be found at: + + git://anongit.freedesktop.org/git/xorg/lib/libXft + + http://cgit.freedesktop.org/xorg/lib/libXft + +For patch submission instructions, see: + + http://www.x.org/wiki/Development/Documentation/SubmittingPatches + +For more information on the git code manager, see: + + http://wiki.x.org/wiki/GitPage + +To release a version of this library: + + 1. Update the version number in configure.ac + 2. Fix the NEWS file + Change version number + Set the date + add highlights + 3. Commit those changes + 4. rebuild the configuration files with autogen.sh + sh autogen.sh --sysconfdir=/etc --prefix=/usr --mandir=/usr/share/man + 5. Follow the steps listed in + http://xorg.freedesktop.org/wiki/Development/Documentation/ReleaseHOWTO + +Keith Packard +keithp@keithp.com + + diff --git a/libXft/autogen.sh b/libXft/autogen.sh new file mode 100644 index 000000000..904cd6746 --- /dev/null +++ b/libXft/autogen.sh @@ -0,0 +1,12 @@ +#! /bin/sh + +srcdir=`dirname $0` +test -z "$srcdir" && srcdir=. + +ORIGDIR=`pwd` +cd $srcdir + +autoreconf -v --install || exit 1 +cd $ORIGDIR || exit $? + +$srcdir/configure --enable-maintainer-mode "$@" diff --git a/libXft/configure.ac b/libXft/configure.ac new file mode 100644 index 000000000..f35eb9109 --- /dev/null +++ b/libXft/configure.ac @@ -0,0 +1,155 @@ +dnl +dnl Copyright © 2003 Keith Packard, Noah Levitt +dnl +dnl Permission to use, copy, modify, distribute, and sell this software and its +dnl documentation for any purpose is hereby granted without fee, provided that +dnl the above copyright notice appear in all copies and that both that +dnl copyright notice and this permission notice appear in supporting +dnl documentation, and that the name of Keith Packard not be used in +dnl advertising or publicity pertaining to distribution of the software without +dnl specific, written prior permission. Keith Packard makes no +dnl representations about the suitability of this software for any purpose. It +dnl is provided "as is" without express or implied warranty. +dnl +dnl KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +dnl INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +dnl EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR +dnl CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +dnl DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +dnl TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +dnl PERFORMANCE OF THIS SOFTWARE. +dnl +dnl Process this file with autoconf to create configure. + +AC_PREREQ([2.60]) + +dnl +dnl This is the package version number, not the shared library +dnl version. This version number will be substituted into Xft.h +dnl Please bump the minor library number at each release as well. +dnl +AC_INIT([libXft], [2.2.0], + [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], [libXft]) +AC_CONFIG_AUX_DIR(.) + +AM_INIT_AUTOMAKE([foreign dist-bzip2]) +AM_MAINTAINER_MODE + +# Require X.Org macros 1.8 or later for MAN_SUBSTS set by XORG_MANPAGE_SECTIONS +m4_ifndef([XORG_MACROS_VERSION], + [m4_fatal([must install xorg-macros 1.8 or later before running autoconf/autogen])]) +XORG_MACROS_VERSION(1.8) +XORG_DEFAULT_OPTIONS +AM_CONFIG_HEADER(config.h) + +# checks for progs +AC_PROG_CC +AC_PROG_LIBTOOL +AC_PROG_SED + +# Set library version for Xft.h from package version set in AC_INIT +# copied from PACKAGE_VERSION_* settings in XORG_VERSION +AC_CONFIG_HEADERS([include/X11/Xft/Xft.h]) +AC_DEFINE_UNQUOTED([XFT_MAJOR], + [`echo $PACKAGE_VERSION | cut -d . -f 1`], + [Major version of Xft]) +AC_DEFINE_UNQUOTED([XFT_MINOR], + [`echo $PACKAGE_VERSION | cut -d . -f 2 | cut -d - -f 1`], + [Minor version of Xft]) +AC_DEFINE_UNQUOTED([XFT_REVISION], + [`echo $PACKAGE_VERSION | cut -d . -f 3 | cut -d - -f 1`], + [Micro revision of Xft]) + +XFT_LT_VERSION=`echo $PACKAGE_VERSION | tr '.' ':'` +AC_SUBST([XFT_LT_VERSION]) + +# +# Check for Xrender +# +PKG_CHECK_MODULES(XRENDER, xrender >= 0.8.2, [xrender_found_with_pkgconfig=yes], + [xrender_found_with_pkgconfig=no]) +case "$xrender_found_with_pkgconfig" in +no) + PKG_CHECK_MODULES(XRENDER, xrender >= 0, [old_xrender_found_with_pkgconfig=yes], + [old_xrender_found_with_pkgconfig=no]) + case "$old_xrender_found_with_pkgconfig" in + yes) + XRENDER_LIBS="$XRENDER_LIBS -lXext -lX11" + ;; + *) + # checks for X + AC_PATH_X + + XRENDER_CFLAGS="-I$x_includes" + XRENDER_LIBS="-L$x_libraries -lXrender -lXext -lX11" + + saved_CPPFLAGS="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $XRENDER_CFLAGS" + AC_CHECK_HEADERS([X11/extensions/Xrender.h], [], [AC_MSG_ERROR([Xrender.h not found.])]) + CPPFLAGS="$saved_CPPFLAGS" + + saved_LIBS="$LIBS" + LIBS="$LIBS $XRENDER_LIBS" + AC_CHECK_FUNCS([XRenderFindStandardFormat], [], [AC_MSG_ERROR([libXrender not found or too old.])]) + LIBS="$saved_LIBS" + ;; + esac + ;; +esac + +# Check freetype configuration +AC_ARG_WITH(freetype-config, [ --with-freetype-config=PROG Use FreeType configuration program PROG], freetype_config=$withval, freetype_config=auto) + +if test "$freetype_config" = "auto"; then + PKG_CHECK_MODULES(FREETYPE, freetype2, + freetype_config=no, freetype_config=yes) +fi + +if test "$freetype_config" = "yes"; then + AC_PATH_PROG(ft_config,freetype-config,no) + if test "$ft_config" = "no"; then + AC_MSG_ERROR([You must have freetype installed; see http://www.freetype.org/]) + fi +else + ft_config="$freetype_config" +fi + +if test "$freetype_config" != "no"; then + FREETYPE_CFLAGS="`$ft_config --cflags`" + FREETYPE_LIBS="`$ft_config --libs`" +fi + +# Check fontconfig configuration +PKG_CHECK_MODULES(FONTCONFIG, fontconfig >= 2.2) + +AC_SUBST(XRENDER_CFLAGS) +AC_SUBST(XRENDER_LIBS) +AC_SUBST(FREETYPE_CFLAGS) +AC_SUBST(FREETYPE_LIBS) +AC_SUBST(FONTCONFIG_CFLAGS) +AC_SUBST(FONTCONFIG_LIBS) + +fontconfig_save_libs="$LIBS" +fontconfig_save_cflags="$CFLAGS" +LIBS="$LIBS $FREETYPE_LIBS" +CFLAGS="$CFLAGS $FREETYPE_CFLAGS" +AC_CHECK_FUNCS(FT_Get_Next_Char FT_Get_BDF_Property FT_Get_PS_Font_Info FT_Has_PS_Glyph_Names FT_GlyphSlot_Embolden) +AC_CHECK_MEMBER(FT_Bitmap_Size.y_ppem, + HAVE_FT_BITMAP_SIZE_Y_PPEM=1, + HAVE_FT_BITMAP_SIZE_Y_PPEM=0, +[#include <ft2build.h> +#include FT_FREETYPE_H]) +AC_DEFINE_UNQUOTED(HAVE_FT_BITMAP_SIZE_Y_PPEM,$HAVE_FT_BITMAP_SIZE_Y_PPEM, + [FT_Bitmap_Size structure includes y_ppem field]) + +LIBS="$fontconfig_save_libs" +CFLAGS="$fontconfig_save_cflags" + +if test "$VERSION" = "" ; then + VERSION=$PACKAGE_VERSION; +fi + +AC_OUTPUT([Makefile + xft.pc + src/Makefile + man/Makefile]) diff --git a/libXft/include/X11/Xft/.gitignore b/libXft/include/X11/Xft/.gitignore new file mode 100644 index 000000000..2aa4925cb --- /dev/null +++ b/libXft/include/X11/Xft/.gitignore @@ -0,0 +1,2 @@ +# Add & Override for this directory and it's subdirectories +Xft.h diff --git a/libXft/include/X11/Xft/Xft.h.in b/libXft/include/X11/Xft/Xft.h.in new file mode 100644 index 000000000..490945fc5 --- /dev/null +++ b/libXft/include/X11/Xft/Xft.h.in @@ -0,0 +1,617 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _XFT_H_ +#define _XFT_H_ + +/* + * Current Xft version number, set from version in the Xft configure.ac file. + */ +/* #undef will be substituted by configure */ +#undef XFT_MAJOR +#undef XFT_MINOR +#undef XFT_REVISION + +#define XFT_VERSION ((XFT_MAJOR * 10000) + (XFT_MINOR * 100) + (XFT_REVISION)) +#define XftVersion XFT_VERSION + +#include <stdarg.h> +#include <ft2build.h> +#include FT_FREETYPE_H +#include <fontconfig/fontconfig.h> +#include <X11/extensions/Xrender.h> + +#include <X11/Xfuncproto.h> +/* #include <X11/Xosdefs.h>*/ +#ifndef _X_SENTINEL +# define _X_SENTINEL(x) +#endif + +#ifndef _XFT_NO_COMPAT_ +#include <X11/Xft/XftCompat.h> +#endif + +#define XFT_CORE "core" +#define XFT_RENDER "render" +#define XFT_XLFD "xlfd" +#define XFT_MAX_GLYPH_MEMORY "maxglyphmemory" +#define XFT_MAX_UNREF_FONTS "maxunreffonts" + +extern FT_Library _XftFTlibrary; + +typedef struct _XftFontInfo XftFontInfo; + +typedef struct _XftFont { + int ascent; + int descent; + int height; + int max_advance_width; + FcCharSet *charset; + FcPattern *pattern; +} XftFont; + +typedef struct _XftDraw XftDraw; + +typedef struct _XftColor { + unsigned long pixel; + XRenderColor color; +} XftColor; + +typedef struct _XftCharSpec { + FcChar32 ucs4; + short x; + short y; +} XftCharSpec; + +typedef struct _XftCharFontSpec { + XftFont *font; + FcChar32 ucs4; + short x; + short y; +} XftCharFontSpec; + +typedef struct _XftGlyphSpec { + FT_UInt glyph; + short x; + short y; +} XftGlyphSpec; + +typedef struct _XftGlyphFontSpec { + XftFont *font; + FT_UInt glyph; + short x; + short y; +} XftGlyphFontSpec; + +_XFUNCPROTOBEGIN + + +/* xftcolor.c */ +Bool +XftColorAllocName (Display *dpy, + _Xconst Visual *visual, + Colormap cmap, + _Xconst char *name, + XftColor *result); + +Bool +XftColorAllocValue (Display *dpy, + Visual *visual, + Colormap cmap, + _Xconst XRenderColor *color, + XftColor *result); + +void +XftColorFree (Display *dpy, + Visual *visual, + Colormap cmap, + XftColor *color); + +/* xftdpy.c */ +Bool +XftDefaultHasRender (Display *dpy); + +Bool +XftDefaultSet (Display *dpy, FcPattern *defaults); + +void +XftDefaultSubstitute (Display *dpy, int screen, FcPattern *pattern); + +/* xftdraw.c */ + +XftDraw * +XftDrawCreate (Display *dpy, + Drawable drawable, + Visual *visual, + Colormap colormap); + +XftDraw * +XftDrawCreateBitmap (Display *dpy, + Pixmap bitmap); + +XftDraw * +XftDrawCreateAlpha (Display *dpy, + Pixmap pixmap, + int depth); + +void +XftDrawChange (XftDraw *draw, + Drawable drawable); + +Display * +XftDrawDisplay (XftDraw *draw); + +Drawable +XftDrawDrawable (XftDraw *draw); + +Colormap +XftDrawColormap (XftDraw *draw); + +Visual * +XftDrawVisual (XftDraw *draw); + +void +XftDrawDestroy (XftDraw *draw); + +Picture +XftDrawPicture (XftDraw *draw); + +Picture +XftDrawSrcPicture (XftDraw *draw, _Xconst XftColor *color); + +void +XftDrawGlyphs (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + int x, + int y, + _Xconst FT_UInt *glyphs, + int nglyphs); + +void +XftDrawString8 (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + int x, + int y, + _Xconst FcChar8 *string, + int len); + +void +XftDrawString16 (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + int x, + int y, + _Xconst FcChar16 *string, + int len); + +void +XftDrawString32 (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + int x, + int y, + _Xconst FcChar32 *string, + int len); + +void +XftDrawStringUtf8 (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + int x, + int y, + _Xconst FcChar8 *string, + int len); + +void +XftDrawStringUtf16 (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + int x, + int y, + _Xconst FcChar8 *string, + FcEndian endian, + int len); + +void +XftDrawCharSpec (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + _Xconst XftCharSpec *chars, + int len); + +void +XftDrawCharFontSpec (XftDraw *draw, + _Xconst XftColor *color, + _Xconst XftCharFontSpec *chars, + int len); + +void +XftDrawGlyphSpec (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + _Xconst XftGlyphSpec *glyphs, + int len); + +void +XftDrawGlyphFontSpec (XftDraw *draw, + _Xconst XftColor *color, + _Xconst XftGlyphFontSpec *glyphs, + int len); + +void +XftDrawRect (XftDraw *draw, + _Xconst XftColor *color, + int x, + int y, + unsigned int width, + unsigned int height); + + +Bool +XftDrawSetClip (XftDraw *draw, + Region r); + + +Bool +XftDrawSetClipRectangles (XftDraw *draw, + int xOrigin, + int yOrigin, + _Xconst XRectangle *rects, + int n); + +void +XftDrawSetSubwindowMode (XftDraw *draw, + int mode); + +/* xftextent.c */ + +void +XftGlyphExtents (Display *dpy, + XftFont *pub, + _Xconst FT_UInt *glyphs, + int nglyphs, + XGlyphInfo *extents); + +void +XftTextExtents8 (Display *dpy, + XftFont *pub, + _Xconst FcChar8 *string, + int len, + XGlyphInfo *extents); + +void +XftTextExtents16 (Display *dpy, + XftFont *pub, + _Xconst FcChar16 *string, + int len, + XGlyphInfo *extents); + +void +XftTextExtents32 (Display *dpy, + XftFont *pub, + _Xconst FcChar32 *string, + int len, + XGlyphInfo *extents); + +void +XftTextExtentsUtf8 (Display *dpy, + XftFont *pub, + _Xconst FcChar8 *string, + int len, + XGlyphInfo *extents); + +void +XftTextExtentsUtf16 (Display *dpy, + XftFont *pub, + _Xconst FcChar8 *string, + FcEndian endian, + int len, + XGlyphInfo *extents); + +/* xftfont.c */ +FcPattern * +XftFontMatch (Display *dpy, + int screen, + _Xconst FcPattern *pattern, + FcResult *result); + +XftFont * +XftFontOpen (Display *dpy, int screen, ...) _X_SENTINEL(0); + +XftFont * +XftFontOpenName (Display *dpy, int screen, _Xconst char *name); + +XftFont * +XftFontOpenXlfd (Display *dpy, int screen, _Xconst char *xlfd); + +/* xftfreetype.c */ + +FT_Face +XftLockFace (XftFont *pub); + +void +XftUnlockFace (XftFont *pub); + +XftFontInfo * +XftFontInfoCreate (Display *dpy, _Xconst FcPattern *pattern); + +void +XftFontInfoDestroy (Display *dpy, XftFontInfo *fi); + +FcChar32 +XftFontInfoHash (_Xconst XftFontInfo *fi); + +FcBool +XftFontInfoEqual (_Xconst XftFontInfo *a, _Xconst XftFontInfo *b); + +XftFont * +XftFontOpenInfo (Display *dpy, + FcPattern *pattern, + XftFontInfo *fi); + +XftFont * +XftFontOpenPattern (Display *dpy, FcPattern *pattern); + +XftFont * +XftFontCopy (Display *dpy, XftFont *pub); + +void +XftFontClose (Display *dpy, XftFont *pub); + +FcBool +XftInitFtLibrary(void); + +/* xftglyphs.c */ +void +XftFontLoadGlyphs (Display *dpy, + XftFont *pub, + FcBool need_bitmaps, + _Xconst FT_UInt *glyphs, + int nglyph); + +void +XftFontUnloadGlyphs (Display *dpy, + XftFont *pub, + _Xconst FT_UInt *glyphs, + int nglyph); + +#define XFT_NMISSING 256 + +FcBool +XftFontCheckGlyph (Display *dpy, + XftFont *pub, + FcBool need_bitmaps, + FT_UInt glyph, + FT_UInt *missing, + int *nmissing); + +FcBool +XftCharExists (Display *dpy, + XftFont *pub, + FcChar32 ucs4); + +FT_UInt +XftCharIndex (Display *dpy, + XftFont *pub, + FcChar32 ucs4); + +/* xftinit.c */ +FcBool +XftInit (_Xconst char *config); + +int +XftGetVersion (void); + +/* xftlist.c */ + +FcFontSet * +XftListFonts (Display *dpy, + int screen, + ...) _X_SENTINEL(0); + +/* xftname.c */ +FcPattern +*XftNameParse (_Xconst char *name); + +/* xftrender.c */ +void +XftGlyphRender (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FT_UInt *glyphs, + int nglyphs); + +void +XftGlyphSpecRender (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + _Xconst XftGlyphSpec *glyphs, + int nglyphs); + +void +XftCharSpecRender (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + _Xconst XftCharSpec *chars, + int len); + +void +XftGlyphFontSpecRender (Display *dpy, + int op, + Picture src, + Picture dst, + int srcx, + int srcy, + _Xconst XftGlyphFontSpec *glyphs, + int nglyphs); + +void +XftCharFontSpecRender (Display *dpy, + int op, + Picture src, + Picture dst, + int srcx, + int srcy, + _Xconst XftCharFontSpec *chars, + int len); + +void +XftTextRender8 (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar8 *string, + int len); + +void +XftTextRender16 (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar16 *string, + int len); + +void +XftTextRender16BE (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar8 *string, + int len); + +void +XftTextRender16LE (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar8 *string, + int len); + +void +XftTextRender32 (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar32 *string, + int len); + +void +XftTextRender32BE (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar8 *string, + int len); + +void +XftTextRender32LE (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar8 *string, + int len); + +void +XftTextRenderUtf8 (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar8 *string, + int len); + +void +XftTextRenderUtf16 (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar8 *string, + FcEndian endian, + int len); + +/* xftxlfd.c */ +FcPattern * +XftXlfdParse (_Xconst char *xlfd_orig, Bool ignore_scalable, Bool complete); + +_XFUNCPROTOEND + +#endif /* _XFT_H_ */ diff --git a/libXft/include/X11/Xft/XftCompat.h b/libXft/include/X11/Xft/XftCompat.h new file mode 100644 index 000000000..0fced03a5 --- /dev/null +++ b/libXft/include/X11/Xft/XftCompat.h @@ -0,0 +1,163 @@ +/* + * Copyright © 2001 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _XFTCOMPAT_H_ +#define _XFTCOMPAT_H_ +#include <X11/Xfuncproto.h> + +/* + * Compatibility definitions -- map Fc names to Xft names + */ + +typedef FcChar8 XftChar8; +typedef FcChar16 XftChar16; +typedef FcChar32 XftChar32; + +#define XFT_FAMILY FC_FAMILY +#define XFT_STYLE FC_STYLE +#define XFT_SLANT FC_SLANT +#define XFT_WEIGHT FC_WEIGHT +#define XFT_SIZE FC_SIZE +#define XFT_PIXEL_SIZE FC_PIXEL_SIZE +#define XFT_SPACING FC_SPACING +#define XFT_FOUNDRY FC_FOUNDRY +#define XFT_ANTIALIAS FC_ANTIALIAS +#define XFT_FILE FC_FILE +#define XFT_INDEX FC_INDEX +#define XFT_RASTERIZER FC_RASTERIZER +#define XFT_OUTLINE FC_OUTLINE +#define XFT_SCALABLE FC_SCALABLE +#define XFT_RGBA FC_RGBA + +/* defaults from resources */ +#define XFT_SCALE FC_SCALE +#define XFT_MINSPACE FC_MINSPACE +#define XFT_DPI FC_DPI + +/* specific to FreeType rasterizer */ +#define XFT_CHAR_WIDTH FC_CHAR_WIDTH +#define XFT_CHAR_HEIGHT FC_CHAR_HEIGHT +#define XFT_MATRIX FC_MATRIX + +#define XFT_WEIGHT_LIGHT FC_WEIGHT_LIGHT +#define XFT_WEIGHT_MEDIUM FC_WEIGHT_MEDIUM +#define XFT_WEIGHT_DEMIBOLD FC_WEIGHT_DEMIBOLD +#define XFT_WEIGHT_BOLD FC_WEIGHT_BOLD +#define XFT_WEIGHT_BLACK FC_WEIGHT_BLACK + +#define XFT_SLANT_ROMAN FC_SLANT_ROMAN +#define XFT_SLANT_ITALIC FC_SLANT_ITALIC +#define XFT_SLANT_OBLIQUE FC_SLANT_OBLIQUE + +#define XFT_PROPORTIONAL FC_PROPORTIONAL +#define XFT_MONO FC_MONO +#define XFT_CHARCELL FC_CHARCELL + +#define XFT_RGBA_UNKNOWN FC_RGBA_UNKNOWN +#define XFT_RGBA_RGB FC_RGBA_RGB +#define XFT_RGBA_BGR FC_RGBA_BGR +#define XFT_RGBA_VRGB FC_RGBA_VRGB +#define XFT_RGBA_VBGR FC_RGBA_VBGR +#define XFT_RGBA_NONE FC_RGBA_NONE + +/* + * Old constants + */ +#define XFT_ENCODING "encoding" + +typedef FcType XftType; + +typedef FcMatrix XftMatrix; + +#define XftMatrixInit(m) FcMatrixInit(m) + +typedef FcResult XftResult; + +#define XftResultMatch FcResultMatch +#define XftResultNoMatch FcResultNoMatch +#define XftResultTypeMismatch FcResultTypeMismatch +#define XftResultNoId FcResultNoId + +typedef FcValue XftValue; +typedef FcPattern XftPattern; +typedef FcFontSet XftFontSet; +typedef FcObjectSet XftObjectSet; + +#define XftGlyphExists XftCharExists + +#define XftObjectSetCreate FcObjectSetCreate +#define XftObjectSetAdd FcObjectSetAdd +#define XftObjectSetDestroy FcObjectSetDestroy +#define XftObjectSetVaBuild FcObjectSetVaBuild +#define XftObjectSetBuild FcObjectSetBuild + +#define XftFontSetMatch FcFontSetMatch +#define XftFontSetDestroy FcFontSetDestroy + +#define XftMatrixEqual FcMatrixEqual +#define XftMatrixMultiply FcMatrixMultiply +#define XftMatrixRotate FcMatrixRotate +#define XftMatrixScale FcMatrixScale +#define XftMatrixShear FcMatrixShear + +#define XftPatternCreate FcPatternCreate +#define XftPatternDuplicate FcPatternDuplicate +#define XftValueDestroy FcValueDestroy +#define XftValueListDestroy FcValueListDestroy +#define XftPatternDestroy FcPatternDestroy +#define XftPatternFind FcPatternFind +#define XftPatternAdd FcPatternAdd +#define XftPatternGet FcPatternGet +#define XftPatternDel FcPatternDel +#define XftPatternAddInteger FcPatternAddInteger +#define XftPatternAddDouble FcPatternAddDouble +#define XftPatternAddString(p,e,s) FcPatternAddString(p,e,(FcChar8 *)(s)) +#define XftPatternAddMatrix FcPatternAddMatrix +#define XftPatternAddBool FcPatternAddBool +#define XftPatternGetInteger FcPatternGetInteger +#define XftPatternGetDouble FcPatternGetDouble +#define XftPatternGetString(p,e,i,n) FcPatternGetString(p,e,i,(FcChar8 **) (n)) +#define XftPatternGetMatrix FcPatternGetMatrix +#define XftPatternGetBool FcPatternGetBool +#define XftPatternVaBuild FcPatternVaBuild +#define XftPatternBuild FcPatternBuild + +#define XftUtf8ToUcs4 FcUtf8ToUcs4 +#define XftUtf8Len FcUtf8Len + +#define XftTypeVoid FcTypeVoid +#define XftTypeInteger FcTypeInteger +#define XftTypeDouble FcTypeDouble +#define XftTypeString FcTypeString +#define XftTypeBool FcTypeBool +#define XftTypeMatrix FcTypeMatrix + +#define XftConfigSubstitute(p) FcConfigSubstitute (0, p, FcMatchPattern) + +_XFUNCPROTOBEGIN + +FcBool +XftNameUnparse (XftPattern *pat, char *dest, int len); + +_XFUNCPROTOEND + +#endif /* _XFTCOMPAT_H_ */ diff --git a/libXft/man/Makefile.am b/libXft/man/Makefile.am new file mode 100644 index 000000000..24e78d819 --- /dev/null +++ b/libXft/man/Makefile.am @@ -0,0 +1,11 @@ +libman_PRE = Xft.man +libmandir = $(LIB_MAN_DIR) +libman_DATA = $(libman_PRE:man=$(LIB_MAN_SUFFIX)) + +EXTRA_DIST = $(libman_PRE) +CLEANFILES = $(libman_DATA) +SUFFIXES = .$(LIB_MAN_SUFFIX) .man + +# String replacements in MAN_SUBSTS now come from xorg-macros.m4 via configure +.man.$(LIB_MAN_SUFFIX): + $(AM_V_GEN)$(SED) $(MAN_SUBSTS) < $< > $@ diff --git a/libXft/man/Xft.man b/libXft/man/Xft.man new file mode 100644 index 000000000..4ed2742d2 --- /dev/null +++ b/libXft/man/Xft.man @@ -0,0 +1,845 @@ +.\" +.\" Copyright © 2000 Keith Packard +.\" +.\" Permission to use, copy, modify, distribute, and sell this software and its +.\" documentation for any purpose is hereby granted without fee, provided that +.\" the above copyright notice appear in all copies and that both that +.\" copyright notice and this permission notice appear in supporting +.\" documentation, and that the name of Keith Packard not be used in +.\" advertising or publicity pertaining to distribution of the software without +.\" specific, written prior permission. Keith Packard makes no +.\" representations about the suitability of this software for any purpose. It +.\" is provided "as is" without express or implied warranty. +.\" +.\" KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +.\" INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +.\" EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR +.\" CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +.\" DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +.\" TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +.\" PERFORMANCE OF THIS SOFTWARE. +.\" +.TH Xft __libmansuffix__ __vendorversion__ +.SH NAME + Xft \- X FreeType interface library +.SH DESCRIPTION +.B Xft +is a simple library designed to interface the FreeType rasterizer with the X +Rendering Extension. +This manual page barely scratches the surface of this library. +.SH "HEADER FILE" +.B #include <X11/Xft/Xft.h> +.SH CONSTANTS +.TP +.B XFT_MAJOR +is the major version number of +.BR Xft . +.TP +.B XFT_MINOR +is the minor version number of +.BR Xft . +.TP +.B XFT_REVISION +is the revision number of +.BR Xft . +.TP +.B XFT_VERSION +is +.B XFT_MAJOR +times 10000 (ten thousand), plus +.B XFT_MINOR +times 100, plus +.BR XFT_REVISION . +.TP +.B XftVersion +is an alias for +.BR XFT_VERSION . +.PP +The following example illustrates how +.BR Xft 's +version constants might be used: +.nf + #if (XFT_VERSION >= 20107) + (void) puts("Version 2.1.7 or later of the Xft library is in" + " use."); + #else + (void) printf("Insufficient version of Xft (%d.%d.%d) installed; + " need at least version 2.1.7.\(rsn", XFT_MAJOR, + XFT_MINOR, + XFT_REVISION); + #endif +.fi +.\" I don't understand what these are for. -- BR, 2005-04-02 +.\" XFT_CORE used in xftname.c +.\" XFT_RENDER used in xftdpy.c, xftfreetype.c, xftname.c +.\" XFT_XLFD used in xftname.c, xftxlfd.c +.\" XFT_MAX_GLYPH_MEMORY used in xftdpy.c, xftfreetype.c +.\" XFT_MAX_UNREF_FONTS used in xftdpy.c +.\" XFT_NMISSING used in xftcore.c, xftextent.c, xftglyphs.c, +.\" xftrender.c +.SH "DATA TYPES" +.TP +.B XftFont +.nf +typedef struct _XftFont { + int ascent; + int descent; + int height; + int max_advance_width; + FcCharSet *charset; + FcPattern *pattern; +} XftFont; +.fi +An +.B XftFont +is the primary data structure of interest to programmers using +.BR Xft ; +it contains general font metrics and pointers to the Fontconfig +character set and pattern associated with the font. +The +.B FcCharSet +and +.B FcPattern +data types are defined by the Fontconfig library. +.TP +.B "" +.BR XftFont s +are populated with any of +.BR XftFontOpen (), +.BR XftFontOpenName (), +.BR XftFontOpenXlfd (), +.BR XftFontOpenInfo (), +or +.BR XftFontOpenPattern (). +.BR XftFontCopy () +is used to duplicate +.BR XftFont s, +and +.BR XftFontClose () +is used to mark an +.B XftFont +as unused. +.BR XftFont s +are internally allocated, reference-counted, and freed by +.BR Xft ; +the programmer does not ordinarily need to allocate or free storage +for them. +.TP +.B "" +.BR XftDrawGlyphs (), +the +.BR XftDrawString *() +family, +.BR XftDrawCharSpec (), +and +.BR XftDrawGlyphSpec () +use +.BR XftFont s +to render text to an +.B XftDraw +object, which may correspond to either a core X drawable or an X +Rendering Extension drawable. +.TP +.B "" +.BR XftGlyphExtents () +and the +.BR XftTextExtents *() +family are used to determine the extents (maximum dimensions) of an +.BR XftFont . +.TP +.B "" +An +.BR XftFont 's +glyph or character coverage can be determined with +.BR XftFontCheckGlyph () +or +.BR XftCharExists (). +.BR XftCharIndex () +returns the +.BR XftFont -specific +character index corresponding to a given Unicode codepoint. +.TP +.B "" +.BR XftGlyphRender (), +.BR XftGlyphSpecRender (), +.BR XftCharSpecRender (), +and the +.BR XftTextRender *() +family use +.BR XftFont s +to draw into X Rendering Extension +.B Picture +structures. +.B Note: +.BR XftDrawGlyphs (), +the +.BR XftDrawString *() +family, +.BR XftDrawCharSpec (), +and +.BR XftDrawGlyphSpec () +provide a means of rendering fonts that is independent of the +availability of the X Rendering Extension on the X server. +.\" I'm not sure what these are for; they're used internally, but why +.\" would any external users want them? -- BR, 2005-04-02 +.\" .BR XftLockFace() +.\" .BR XftUnlockFace() +.TP +.B XftFontInfo +is an opaque object that stores information about a font. +.B XftFontInfo +structures are created with +.BR XftFontInfoCreate (), +freed with +.BR XftFontInfoDestroy (), +and compared with +.BR XftFontInfoEqual (). +.B XftFontInfo +objects are internally allocated and freed by +.BR Xft ; +the programmer does not ordinarily need to allocate or free storage +for them. +.TP +.B "" +Each +.B XftFontInfo +structure in use is associated with a unique identifier, which can be +retrieved with +.BR XftFontInfoHash (). +An +.B XftFont +can be opened based on +.B XftFontInfo +data with +.BR XftFontOpenInfo (). +.TP +.B XftColor +.nf +typedef struct _XftColor { + unsigned long pixel; + XRenderColor color; +} XftColor; +.fi +An +.B XftColor +object permits text and other items to be rendered in a particular +color (or the closest approximation offered by the X visual in use). +The +.B XRenderColor +data type is defined by the X Render Extension library. +.TP +.B "" +.BR XftColorAllocName () +and +.BR XftColorAllocValue () +request a color allocation from the X server (if necessary) and +initialize the members of +.BR XftColor . +.BR XftColorFree () +instructs the X server to free the color currently allocated for an +.BR XftColor . +.TP +.B "" +One an +.B XftColor +has been initialized, +.BR XftDrawSrcPicture (), +.BR XftDrawGlyphs (), +the +.BR XftDrawString *() +family, +.BR XftDrawCharSpec (), +.BR XftDrawCharFontSpec (), +.BR XftDrawGlyphSpec (), +.BR XftDrawGlyphFontSpec (), +and +.BR XftDrawRect () +may be used to draw various objects using it. +.TP +.B XftDraw +is an opaque object which holds information used to render to an X drawable +using either the core protocol or the X Rendering extension. +.TP +.B "" +.B XftDraw +objects are created with any of +.BR XftDrawCreate () +(which associates an +.B XftDraw +with an existing X drawable), +.BR XftDrawCreateBitmap (), +or +.BR XftDrawCreateAlpha (), +and destroyed with +.BR XftDrawDestroy (). +The X drawable associated with an +.B XftDraw +can be changed with +.BR XftDrawChange (). +.BR XftDraw s +are internally allocated and freed by +.BR Xft ; +the programmer does not ordinarily need to allocate or free storage +for them. +.TP +.B "" +The X +.BR Display , +.BR Drawable , +.BR Colormap , +and +.BR Visual +of an +.B XftDraw +can be queried with +.BR XftDrawDisplay (), +.BR XftDrawDrawable (), +.BR XftDrawColormap (), +and +.BR XftDrawVisual (), +respectively. +The X Rendering Extension +.B Picture +associated with an +.B XftDraw +is returned by +.BR XftDrawPicture (). +.\" XftDrawSrcPicture +.\" XftDrawGlyphs +.\" XftDrawString* +.\" XftDrawCharSpec +.\" XftDrawCharFontSpec +.\" XftDrawGlyphSpec +.\" XftDrawGlyphFontSpec +.\" XftDrawRect +.\" XftDrawSetClip +.\" XftDrawSetClipRectangles +.\" XftDrawSetSubwindowMode +.TP +.B XftCharSpec +.nf +typedef struct _XftCharSpec { + FcChar32 ucs4; + short x; + short y; +} XftCharSpec; +.fi +.TP +.B "" +The +.B FcChar32 +data type is defined by the Fontconfig library. +.\" XftDrawCharSpec +.\" XftCharSpecRender +.TP +.B XftCharFontSpec +.nf +typedef struct _XftCharFontSpec { + XftFont *font; + FcChar32 ucs4; + short x; + short y; +} XftCharFontSpec; +.fi +.TP +.B "" +The +.B FcChar32 +data type is defined by the Fontconfig library. +.\" XftDrawCharFontSpec +.\" XftCharFontSpecRender +.TP +.B XftGlyphSpec +.nf +typedef struct _XftGlyphSpec { + FT_UInt glyph; + short x; + short y; +} XftGlyphSpec; +.fi +.TP +.B "" +The +.B FT_UInt +data type is defined by the FreeType library. +.\" XftDrawGlyphSpec +.\" XftGlyphSpecRender +.TP +.B XftGlyphFontSpec +.nf +typedef struct _XftGlyphFontSpec { + XftFont *font; + FT_UInt glyph; + short x; + short y; +} XftGlyphFontSpec; +.fi +.TP +.B "" +The +.B FT_UInt +data type is defined by the FreeType library. +.\" XftDrawGlyphFontSpec +.\" XftGlyphFontSpecRender +.SH FUNCTIONS +.SS "Opening and Matching Fonts" +.nf +\fBXftFont *\fR +\fBXftFontOpen (Display *\fIdpy\fB,\fR +\fB int \fIscreen\fB,\fR +\fB ...);\fR\fR +.fi +.B XftFontOpen +takes a list of pattern element triples of the form +.IR field , " type" , " value" +(terminated with a NULL), matches that pattern against the available fonts, +and opens the matching font, sizing it correctly for screen number +.I screen +on display +.IR dpy . +The +.B Display +data type is defined by the X11 library. +Returns NULL if no match is found. +.PP +Example: +.nf + font = XftFontOpen (dpy, screen, + XFT_FAMILY, XftTypeString, "charter", + XFT_SIZE, XftTypeDouble, 12.0, + NULL); +.fi +This opens the \(lqcharter\(rq font at 12 points. +The point size is automatically converted to the correct pixel size based +on the resolution of the monitor. +.PP +.nf +\fBXftFont *\fR +\fBXftFontOpenName (Display *\fIdpy\fB,\fR +\fB int \fIscreen\fB,\fR +\fB unsigned char *\fIname\fB);\fR +.fi +.B XftFontOpenName +behaves as +.B XftFontOpen +does, except that it takes a Fontconfig pattern string (which is passed to +the Fontconfig library's +.BR FcNameParse () +function). +.PP +.nf +\fBXftFont *\fR +\fBXftFontOpenXlfd (Display *\fIdpy\fB,\fR +\fB int \fIscreen\fB,\fR +\fB unsigned char *\fIxlfd\fB)\fR +.fi +.B XftFontOpenXlfd +behaves as +.B XftFontOpen +does, except that it takes a string containing an X Logical Font +Description (XLFD). +.PP +.nf +\fBFcPattern *\fR +\fBXftFontMatch (Display *\fIdpy\fB,\fR +\fB int \fIscreen\fB,\fR +\fB FcPattern *\fIpattern\fB,\fR +\fB FcResult *\fIresult\fB);\fR +.fi +Also used internally by the +.BR XftFontOpen * +functions, +.B XftFontMatch +can also be used directly to determine the Fontconfig font pattern +resulting from an Xft font open request. +The +.B FcPattern +and +.B FcResult +data types are defined by the Fontconfig library. +.SS "Determining the Pixel Extents of a Text String" +.nf +\fBvoid\fR +\fBXftTextExtents8 (Display *\fIdpy\fB,\fR +\fB XftFont *\fIfont\fB,\fR +\fB FcChar8 *\fIstring\fB,\fR +\fB int \fIlen\fB,\fR +\fB XGlyphInfo *\fIextents\fB);\fR +.fi +.B XftTextExtents8 +computes the pixel extents on display +.I dpy +of no more than +.I len +glyphs of a +.I string +consisting of eight-bit characters when drawn with +.IR font , +storing them in +.IR extents . +The +.B FcChar8 +data type is defined by the Fontconfig library, and the +.B XGlyphInfo +data type is defined by the X Rendering Extension library. +.PP +.nf +\fBvoid\fR +\fBXftTextExtents16 (Display *\fIdpy\fB,\fR +\fB XftFont *\fIfont\fB,\fR +\fB FcChar16 *\fIstring\fB,\fR +\fB int \fIlen\fB,\fR +\fB XGlyphInfo *\fIextents\fB);\fR +.fi +.B XftTextExtents16 +computes the pixel extents on display +.I dpy +of no more than +.I len +glyphs of a +.I string +consisting of sixteen-bit characters when drawn with +.IR font , +storing them in +.IR extents . +The +.B FcChar16 +data type is defined by the Fontconfig library, and the +.B XGlyphInfo +data type is defined by the X Rendering Extension library. +.PP +.nf +\fBvoid\fR +\fBXftTextExtents32 (Display *\fIdpy\fB,\fR +\fB XftFont *\fIfont\fB,\fR +\fB FcChar32 *\fIstring\fB,\fR +\fB int \fIlen\fB,\fR +\fB XGlyphInfo *\fIextents\fB);\fR +.fi +.B XftTextExtents32 +computes the pixel extents on display +.I dpy +of no more than +.I len +glyphs of a +.I string +consisting of thirty-two-bit characters when drawn with +.IR font , +storing them in +.IR extents . +The +.B FcChar32 +data type is defined by the Fontconfig library, and the +.B XGlyphInfo +data type is defined by the X Rendering Extension library. +.PP +.nf +\fBvoid\fR +\fBXftTextExtentsUtf8 (Display *\fIdpy\fB,\fR +\fB XftFont *\fIfont\fB,\fR +\fB FcChar8 *\fIstring\fB,\fR +\fB int \fIlen\fB,\fR +\fB XGlyphInfo *\fIextents\fB);\fR +.fi +.B XftTextExtentsUtf8 +computes the pixel extents on display +.I dpy +of no more than +.I len +bytes of a UTF-8 encoded +.I string +when drawn with +.IR font , +storing them in +.IR extents . +The +.B XGlyphInfo +data type is defined by the X Rendering Extension library. +.PP +.nf +\fBvoid\fR +\fBXftTextExtentsUtf16 (Display *\fIdpy\fB,\fR +\fB XftFont *\fIfont\fB,\fR +\fB FcChar8 *\fIstring\fB,\fR +\fB FcEndian \fIendian\fB,\fR +\fB int \fIlen\fB,\fR +\fB XGlyphInfo *\fIextents\fB);\fR +.fi +.B XftTextExtentsUtf16 +computes the pixel extents on display +.I dpy +of no more than +.I len +bytes of a UTF-16LE- or UTF-16BE-encoded +.I string +when drawn with +.IR font , +storing them in +.IR extents . +The endianness of +.I string +must be specified in +.IR endian . +The +.B FcEndian +data type is defined by the Fontconfig library, and the +.B XGlyphInfo +data type is defined by the X Rendering Extension library. +.PP +.nf +\fBvoid\fR +\fBXftGlyphExtents (Display *\fIdpy\fB,\fR +\fB XftFont *\fIfont\fB,\fR +\fB FT_UInt *\fIglyphs\fB,\fR +\fB int \fInglyphs\fB,\fR +\fB XGlyphInfo *\fIextents\fB);\fR +.fi +Also used internally by the +.BR XftTextExtents * +functions, +.B XftGlyphExtents +computes the pixel extents on display +.I dpy +of no more than +.I nglyphs +in the array +.I glyphs +drawn with +.IR font , +storing them in +.IR extents . +The +.B FT_UInt +data type is defined by the FreeType library, and the +.B XGlyphInfo +data type is defined by the X Rendering Extension library. +.SS "Drawing Strings (and Other Things)" +.nf +\fBXftDraw *\fR +\fBXftDrawCreate (Display *\fIdpy\fB,\fR +\fB Drawable \fIdrawable\fB,\fR +\fB Visual *\fIvisual\fB,\fR +\fB Colormap \fIcolormap\fB);\fR +.fi +.B XftDrawCreate +creates a structure that can be used to render text and rectangles using +the specified +.IR drawable , +.IR visual , +and +.I colormap +on +.IR display . +The +.BR Drawable , +.BR Visual , +and +.B Colormap +data types are defined by the X11 library. +.PP +.nf +\fBXftDraw *\fR +\fBXftDrawCreateBitmap (Display *\fIdpy\fB,\fR +\fB Pixmap \fIbitmap\fB);\fR +.fi +.B XftDrawCreateBitmap +behaves as +.BR XftDrawCreate , +except it uses an X pixmap of color depth 1 instead of an X drawable. +The +.B Pixmap +data type is defined by the X11 library. +.PP +.nf +\fBXftDraw *\fR +\fBXftDrawCreateAlpha (Display *\fIdpy\fB,\fR +\fB Pixmap \fIpixmap\fB,\fR +\fB int \fIdepth\fB);\fR +.fi +.B XftDrawCreateAlpha +behaves as +.BR XftDrawCreate , +except it uses an X pixmap of color depth +.I depth +instead of an X drawable. +The +.B Pixmap +data type is defined by the X11 library. +.PP +.nf +\fBvoid\fR +\fBXftDrawChange (XftDraw *\fIdraw\fB,\fR +\fB Drawable \fIdrawable\fB);\fR +.fi +.B XftDrawChange +changes the X drawable association of the existing Xft draw object +.I draw +from its current value to +.IR drawable . +.PP +.nf +\fBDisplay *\fR +\fBXftDrawDisplay (XftDraw *\fIdraw\fB);\fR +.fi +.B XftDrawDisplay +returns a pointer to the display associated with the Xft draw object +.IR draw . +.PP +.nf +\fBDrawable\fR +\fBXftDrawDrawable (XftDraw *\fIdraw\fB);\fR +.fi +.B XftDrawDrawable +returns the X drawable associated with the Xft draw object +.IR draw . +.PP +.nf +\fBColormap\fR +\fBXftDrawColormap (XftDraw *\fIdraw\fB);\fR +.fi +.B XftDrawColormap +returns the colormap associatied with the Xft draw object +.IR draw . +.PP +.nf +\fBVisual *\fR +\fBXftDrawVisual (XftDraw *\fIdraw\fB);\fR +.fi +.B XftDrawVisual +returns a pointer to the visual associated with the Xft draw object +.IR draw . +.PP +.nf +\fBPicture\fR +\fBXftDrawPicture (XftDraw *\fIdraw\fB);\fR +.fi +.B XftDrawPicture +returns the picture associated with the Xft draw object +.IR draw . +If the the X server does not support the X Rendering Extension, 0 is +returned. +.PP +.nf +\fBPicture\fR +\fBXftDrawSrcPicture (XftDraw *\fIdraw\fB,\fR +\fB XftColor *\fIcolor\fB);\fR +.fi +.\" Unfortunately, I'm not quite sure what this does. I think it is the gizmo +.\" that is used to create an Xrender Picture object so that glyphs can be +.\" drawn in the XftDraw object +.\" .I draw +.\" using the specified +.\" .IR color . +.\" -- BR, 2005-04-02 +This function is never called if the X server doesn't support the X +Rendering Extension; instead, +.B XftGlyphCore +is used. +.PP +.nf +\fBvoid\fR +\fBXftDrawDestroy (XftDraw *\fIdraw\fB);\fR +.fi +.B XftDrawDestroy +destroys +.I draw +(created by one of the +.B XftCreate +functions) and frees the memory that was allocated for it. +.PP +.nf +\fBvoid\fR +\fBXftDrawString8 (XftDraw *\fId\fB,\fR +\fB XRenderColor *\fIcolor\fB,\fR +\fB XftFont *\fIfont\fB,\fR +\fB int \fIx\fB,\fR +\fB int \fIy\fB,\fR +\fB unsigned char *\fIstring\fB,\fR +\fB int \fIlen\fB);\fR +.fi +.B XftDrawString8 +draws no more than +.I len +glyphs of +.I string +to Xft drawable +.I d +using +.I font +in +.I color +at position +.IR x , " y" . +The +.B XRenderColor +data type is defined by the X Rendering Extension library. +.PP +.nf +\fBvoid\fR +\fBXftDrawRect (XftDraw *\fId\fB,\fR +\fB XRenderColor *\fIcolor\fB,\fR +\fB int \fIx\fB,\fR +\fB int \fIy\fB,\fR +\fB unsigned int \fIwidth\fB,\fR +\fB unsigned int \fIheight\fB);\fR +.fi +.B XftDrawRect +draws a solid rectangle of the specified +.IR color , +.IR width , +and +.I height +at position +.IR x , " y" +to Xft drawable +.IR d . +.SH COMPATIBILITY +As of version 2, +.B Xft +has become relatively stable and is expected to retain source and binary +compatibility in future releases. +.PP +.B Xft +does provide a compatibility interface to its previous major version, +Xft +.RI 1. x , +described below. +.SS "Xft 1.x Compatibility Header File" +.B #include <X11/Xft/XftCompat.h> +.\" .SS "Xft 1.x Compatibility Constants" +.SS "Xft 1.x Compatibility Data Types" +.TP +.B XftPattern +holds a set of names with associated value lists; each name refers to a +property of a font. +.BR XftPattern s +are used as inputs to the matching code as well as holding information +about specific fonts. +.TP +.B XftFontSet +contains a list of +.BR XftPattern s. +Internally, +.B Xft +uses this data structure to hold sets of fonts. +Externally, +.B Xft +returns the results of listing fonts in this format. +.TP +.B XftObjectSet +holds a set of names and is used to specify which fields from fonts are +placed in the the list of returned patterns when listing fonts. +.\" .SS "Xft 1.x Compatibility Functions" +.SH AUTHOR +Keith Packard +.SH "SEE ALSO" +.I Fontconfig Developers Reference +.br +.I FreeType API Reference +.br +.I Xlib \- C Language Interface +.\" Set Vim modeline; textwidth is 70 to account for the extra margin +.\" padding that man (on Debian GNU/Linux) does for output to +.\" terminals (7 spaces on the left, 2 on the right), so that we don't +.\" go past 80 columns total, particularly in .nf/.fi regions. +.\" vim:set ai et sts=4 sw=4 tw=70: diff --git a/libXft/src/Makefile.am b/libXft/src/Makefile.am new file mode 100644 index 000000000..d9604a02c --- /dev/null +++ b/libXft/src/Makefile.am @@ -0,0 +1,32 @@ +AM_CFLAGS = $(FONTCONFIG_CFLAGS) $(FREETYPE_CFLAGS) $(XRENDER_CFLAGS) \ + $(CWARNFLAGS) -I$(top_builddir)/include/X11/Xft + +lib_LTLIBRARIES = libXft.la + +libXft_la_SOURCES = xftint.h \ + xftcolor.c \ + xftcore.c \ + xftdbg.c \ + xftdpy.c \ + xftdraw.c \ + xftextent.c \ + xftfont.c \ + xftfreetype.c \ + xftglyphs.c \ + xftinit.c \ + xftlist.c \ + xftname.c \ + xftrender.c \ + xftstr.c \ + xftswap.c \ + xftxlfd.c + +libXft_la_LIBADD = @FONTCONFIG_LIBS@ @FREETYPE_LIBS@ @XRENDER_LIBS@ + +# -version-number requires libtool >= 1.5 +libXft_la_LDFLAGS = -version-number $(XFT_LT_VERSION) -no-undefined + +libXftincludedir = $(includedir)/X11/Xft +libXftinclude_HEADERS = \ + $(top_builddir)/include/X11/Xft/Xft.h \ + $(top_srcdir)/include/X11/Xft/XftCompat.h diff --git a/libXft/src/xftcolor.c b/libXft/src/xftcolor.c new file mode 100644 index 000000000..77872efa4 --- /dev/null +++ b/libXft/src/xftcolor.c @@ -0,0 +1,123 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +_X_EXPORT Bool +XftColorAllocName (Display *dpy, + _Xconst Visual *visual, + Colormap cmap, + _Xconst char *name, + XftColor *result) +{ + XColor screen, exact; + + if (!XAllocNamedColor (dpy, cmap, name, &screen, &exact)) + { + /* XXX stick standard colormap stuff here */ + return False; + } + + result->pixel = screen.pixel; + result->color.red = exact.red; + result->color.green = exact.green; + result->color.blue = exact.blue; + result->color.alpha = 0xffff; + return True; +} + +static short +maskbase (unsigned long m) +{ + short i; + + if (!m) + return 0; + i = 0; + while (!(m&1)) + { + m>>=1; + i++; + } + return i; +} + +static short +masklen (unsigned long m) +{ + unsigned long y; + + y = (m >> 1) &033333333333; + y = m - y - ((y >>1) & 033333333333); + return (short) (((y + (y >> 3)) & 030707070707) % 077); +} + +_X_EXPORT Bool +XftColorAllocValue (Display *dpy, + Visual *visual, + Colormap cmap, + _Xconst XRenderColor *color, + XftColor *result) +{ + if (visual->class == TrueColor) + { + int red_shift, red_len; + int green_shift, green_len; + int blue_shift, blue_len; + + red_shift = maskbase (visual->red_mask); + red_len = masklen (visual->red_mask); + green_shift = maskbase (visual->green_mask); + green_len = masklen (visual->green_mask); + blue_shift = maskbase (visual->blue_mask); + blue_len = masklen (visual->blue_mask); + result->pixel = (((color->red >> (16 - red_len)) << red_shift) | + ((color->green >> (16 - green_len)) << green_shift) | + ((color->blue >> (16 - blue_len)) << blue_shift)); + } + else + { + XColor xcolor; + + xcolor.red = color->red; + xcolor.green = color->green; + xcolor.blue = color->blue; + if (!XAllocColor (dpy, cmap, &xcolor)) + return False; + result->pixel = xcolor.pixel; + } + result->color.red = color->red; + result->color.green = color->green; + result->color.blue = color->blue; + result->color.alpha = color->alpha; + return True; +} + +_X_EXPORT void +XftColorFree (Display *dpy, + Visual *visual, + Colormap cmap, + XftColor *color) +{ + if (visual->class != TrueColor) + XFreeColors (dpy, cmap, &color->pixel, 1, 0); +} diff --git a/libXft/src/xftcore.c b/libXft/src/xftcore.c new file mode 100644 index 000000000..3f8710929 --- /dev/null +++ b/libXft/src/xftcore.c @@ -0,0 +1,1373 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +_X_HIDDEN void +XftRectCore (XftDraw *draw, + _Xconst XftColor *color, + int x, + int y, + unsigned int width, + unsigned int height) +{ + if (color->color.alpha >= 0x8000) + { + XSetForeground (draw->dpy, draw->core.gc, color->pixel); + XFillRectangle (draw->dpy, draw->drawable, draw->core.gc, + x, y, width, height); + } +} + +/* + * Use the core protocol to draw the glyphs + */ + +static void +_XftSharpGlyphMono (XftDraw *draw, + XftGlyph *glyph, + int x, + int y) +{ + unsigned char *srcLine = glyph->bitmap, *src; + unsigned char bits, bitsMask; + int width = glyph->metrics.width; + int stride = ((width + 31) & ~31) >> 3; + int height = glyph->metrics.height; + int w; + int xspan, lenspan; + + x -= glyph->metrics.x; + y -= glyph->metrics.y; + while (height--) + { + src = srcLine; + srcLine += stride; + w = width; + + bitsMask = 0x80; /* FreeType is always MSB first */ + bits = *src++; + + xspan = x; + while (w) + { + if (bits & bitsMask) + { + lenspan = 0; + do + { + lenspan++; + if (lenspan == w) + break; + bitsMask = bitsMask >> 1; + if (!bitsMask) + { + bits = *src++; + bitsMask = 0x80; + } + } while (bits & bitsMask); + XFillRectangle (draw->dpy, draw->drawable, + draw->core.gc, xspan, y, lenspan, 1); + xspan += lenspan; + w -= lenspan; + } + else + { + do + { + w--; + xspan++; + if (!w) + break; + bitsMask = bitsMask >> 1; + if (!bitsMask) + { + bits = *src++; + bitsMask = 0x80; + } + } while (!(bits & bitsMask)); + } + } + y++; + } +} + +/* + * Draw solid color text from an anti-aliased bitmap. This is a + * fallback for cases where a particular drawable has no AA code + */ +static void +_XftSharpGlyphGray (XftDraw *draw, + XftGlyph *glyph, + int x, + int y) +{ + unsigned char *srcLine = glyph->bitmap, *src, bits; + int width = glyph->metrics.width; + int stride = ((width + 3) & ~3); + int height = glyph->metrics.height; + int w; + int xspan, lenspan; + + x -= glyph->metrics.x; + y -= glyph->metrics.y; + while (height--) + { + src = srcLine; + srcLine += stride; + w = width; + + bits = *src++; + xspan = x; + while (w) + { + if (bits >= 0x80) + { + lenspan = 0; + do + { + lenspan++; + if (lenspan == w) + break; + bits = *src++; + } while (bits >= 0x80); + XFillRectangle (draw->dpy, draw->drawable, + draw->core.gc, xspan, y, lenspan, 1); + xspan += lenspan; + w -= lenspan; + } + else + { + do + { + w--; + xspan++; + if (!w) + break; + bits = *src++; + } while (bits < 0x80); + } + } + y++; + } +} + +static void +_XftSharpGlyphRgba (XftDraw *draw, + XftGlyph *glyph, + int x, + int y) +{ + CARD32 *srcLine = glyph->bitmap, *src, bits; + int width = glyph->metrics.width; + int stride = ((width + 3) & ~3); + int height = glyph->metrics.height; + int w; + int xspan, lenspan; + + x -= glyph->metrics.x; + y -= glyph->metrics.y; + while (height--) + { + src = srcLine; + srcLine += stride; + w = width; + + bits = *src++; + xspan = x; + while (w) + { + if (bits >= 0x80000000) + { + lenspan = 0; + do + { + lenspan++; + if (lenspan == w) + break; + bits = *src++; + } while (bits >= 0x80000000); + XFillRectangle (draw->dpy, draw->drawable, + draw->core.gc, xspan, y, lenspan, 1); + xspan += lenspan; + w -= lenspan; + } + else + { + do + { + w--; + xspan++; + if (!w) + break; + bits = *src++; + } while (bits < 0x80000000); + } + } + y++; + } +} + +typedef void (*XftSharpGlyph) (XftDraw *draw, + XftGlyph *glyph, + int x, + int y); + +static XftSharpGlyph +_XftSharpGlyphFind (XftDraw *draw, XftFont *public) +{ + XftFontInt *font = (XftFontInt *) public; + + if (!font->info.antialias) + return _XftSharpGlyphMono; + else switch (font->info.rgba) { + case FC_RGBA_RGB: + case FC_RGBA_BGR: + case FC_RGBA_VRGB: + case FC_RGBA_VBGR: + return _XftSharpGlyphRgba; + default: + return _XftSharpGlyphGray; + } +} + +/* + * Draw glyphs to a target that supports anti-aliasing + */ + +/* + * Primitives for converting between RGB values and TrueColor pixels + */ + +static void +_XftExamineBitfield (unsigned long mask, int *shift, int *len) +{ + int s, l; + + s = 0; + while ((mask & 1) == 0) + { + mask >>= 1; + s++; + } + l = 0; + while ((mask & 1) == 1) + { + mask >>= 1; + l++; + } + *shift = s; + *len = l; +} + +static CARD32 +_XftGetField (unsigned long l_pixel, int shift, int len) +{ + CARD32 pixel = (CARD32) l_pixel; + + pixel = pixel & (((1 << (len)) - 1) << shift); + pixel = pixel << (32 - (shift + len)) >> 24; + while (len < 8) + { + pixel |= (pixel >> len); + len <<= 1; + } + return pixel; +} + +static unsigned long +_XftPutField (CARD32 pixel, int shift, int len) +{ + unsigned long l_pixel = (unsigned long) pixel; + + shift = shift - (8 - len); + if (len <= 8) + l_pixel &= (((1 << len) - 1) << (8 - len)); + if (shift < 0) + l_pixel >>= -shift; + else + l_pixel <<= shift; + return l_pixel; +} + +/* + * This is used when doing XftCharFontSpec/XftGlyphFontSpec where + * some of the fonts are bitmaps and some are anti-aliased to handle + * the bitmap portions + */ +static void +_XftSmoothGlyphMono (XImage *image, + _Xconst XftGlyph *xftg, + int x, + int y, + _Xconst XftColor *color) +{ + unsigned char *srcLine = xftg->bitmap, *src; + unsigned char bits, bitsMask; + int width = xftg->metrics.width; + int stride = ((width + 31) & ~31) >> 3; + int height = xftg->metrics.height; + int w; + int xspan; + int r_shift, r_len; + int g_shift, g_len; + int b_shift, b_len; + unsigned long pixel; + + _XftExamineBitfield (image->red_mask, &r_shift, &r_len); + _XftExamineBitfield (image->green_mask, &g_shift, &g_len); + _XftExamineBitfield (image->blue_mask, &b_shift, &b_len); + pixel = (_XftPutField (color->color.red >> 8, r_shift, r_len) | + _XftPutField (color->color.green >> 8, g_shift, g_len) | + _XftPutField (color->color.blue >> 8, b_shift, b_len)); + x -= xftg->metrics.x; + y -= xftg->metrics.y; + while (height--) + { + src = srcLine; + srcLine += stride; + w = width; + + bitsMask = 0x80; /* FreeType is always MSB first */ + bits = *src++; + + xspan = x; + while (w--) + { + if (bits & bitsMask) + XPutPixel (image, xspan, y, pixel); + bitsMask = bitsMask >> 1; + if (!bitsMask) + { + bits = *src++; + bitsMask = 0x80; + } + xspan++; + } + y++; + } +} + +/* + * As simple anti-aliasing is likely to be common, there are three + * optimized versions for the usual true color pixel formats (888, 565, 555). + * Other formats are handled by the general case + */ + +#define cvt8888to0565(s) ((((s) >> 3) & 0x001f) | \ + (((s) >> 5) & 0x07e0) | \ + (((s) >> 8) & 0xf800)) + +#define cvt0565to8888(s) (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) | \ + ((((s) << 5) & 0xfc00) | (((s) >> 1) & 0x300)) | \ + ((((s) << 8) & 0xf80000) | (((s) << 3) & 0x70000))) + +#define cvt8888to0555(s) ((((s) >> 3) & 0x001f) | \ + (((s) >> 6) & 0x03e0) | \ + (((s) >> 7) & 0x7c00)) + +#define cvt0555to8888(s) (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) | \ + ((((s) << 6) & 0xf800) | (((s) >> 0) & 0x300)) | \ + ((((s) << 9) & 0xf80000) | (((s) << 4) & 0x70000))) + + +#define XftIntMult(a,b,t) ( (t) = (a) * (b) + 0x80, ( ( ( (t)>>8 ) + (t) )>>8 ) ) +#define XftIntDiv(a,b) (((CARD16) (a) * 255) / (b)) + +#define XftGet8(v,i) ((CARD16) (CARD8) ((v) >> i)) + +/* + * There are two ways of handling alpha -- either as a single unified value or + * a separate value for each component, hence each macro must have two + * versions. The unified alpha version has a 'U' at the end of the name, + * the component version has a 'C'. Similarly, functions which deal with + * this difference will have two versions using the same convention. + */ + +#define XftOverU(x,y,i,a,t) ((t) = XftIntMult(XftGet8(y,i),(a),(t)) + XftGet8(x,i),\ + (CARD32) ((CARD8) ((t) | (0 - ((t) >> 8)))) << (i)) + +#define XftOverC(x,y,i,a,t) ((t) = XftIntMult(XftGet8(y,i),XftGet8(a,i),(t)) + XftGet8(x,i),\ + (CARD32) ((CARD8) ((t) | (0 - ((t) >> 8)))) << (i)) + +#define XftInU(x,i,a,t) ((CARD32) XftIntMult(XftGet8(x,i),(a),(t)) << (i)) + +#define XftInC(x,i,a,t) ((CARD32) XftIntMult(XftGet8(x,i),XftGet8(a,i),(t)) << (i)) + +#define XftGen(x,y,i,ax,ay,t,u,v) ((t) = (XftIntMult(XftGet8(y,i),ay,(u)) + \ + XftIntMult(XftGet8(x,i),ax,(v))),\ + (CARD32) ((CARD8) ((t) | \ + (0 - ((t) >> 8)))) << (i)) + +#define XftAdd(x,y,i,t) ((t) = XftGet8(x,i) + XftGet8(y,i), \ + (CARD32) ((CARD8) ((t) | (0 - ((t) >> 8)))) << (i)) + + +static CARD32 +fbOver24 (CARD32 x, CARD32 y) +{ + CARD16 a = ~x >> 24; + CARD16 t; + CARD32 m,n,o; + + m = XftOverU(x,y,0,a,t); + n = XftOverU(x,y,8,a,t); + o = XftOverU(x,y,16,a,t); + return m|n|o; +} + +static CARD32 +fbIn (CARD32 x, CARD8 y) +{ + CARD16 a = y; + CARD16 t; + CARD32 m,n,o,p; + + m = XftInU(x,0,a,t); + n = XftInU(x,8,a,t); + o = XftInU(x,16,a,t); + p = XftInU(x,24,a,t); + return m|n|o|p; +} + +static void +_XftSmoothGlyphGray8888 (XImage *image, + _Xconst XftGlyph *xftg, + int x, + int y, + _Xconst XftColor *color) +{ + CARD32 src, srca; + CARD32 r, g, b; + CARD32 *dstLine, *dst, d; + CARD8 *maskLine, *mask, m; + int dstStride, maskStride; + int width, height; + int w; + + srca = color->color.alpha >> 8; + + /* This handles only RGB and BGR */ + g = (color->color.green & 0xff00); + if (image->red_mask == 0xff0000) + { + r = (color->color.red & 0xff00) << 8; + b = color->color.blue >> 8; + } + else + { + r = color->color.red >> 8; + b = (color->color.blue & 0xff00) << 8; + } + src = (srca << 24) | r | g | b; + + width = xftg->metrics.width; + height = xftg->metrics.height; + + x -= xftg->metrics.x; + y -= xftg->metrics.y; + + dstLine = (CARD32 *) (image->data + image->bytes_per_line * y + (x << 2)); + dstStride = image->bytes_per_line >> 2; + maskLine = (unsigned char *) xftg->bitmap; + maskStride = (width + 3) & ~3; + + while (height--) + { + dst = dstLine; + dstLine += dstStride; + mask = maskLine; + maskLine += maskStride; + w = width; + + while (w--) + { + m = *mask++; + if (m == 0xff) + { + if (srca == 0xff) + *dst = src; + else + *dst = fbOver24 (src, *dst); + } + else if (m) + { + d = fbIn (src, m); + *dst = fbOver24 (d, *dst); + } + dst++; + } + } +} + +static void +_XftSmoothGlyphGray565 (XImage *image, + _Xconst XftGlyph *xftg, + int x, + int y, + _Xconst XftColor *color) +{ + CARD32 src, srca; + CARD32 r, g, b; + CARD32 d; + CARD16 *dstLine, *dst; + CARD8 *maskLine, *mask, m; + int dstStride, maskStride; + int width, height; + int w; + + srca = color->color.alpha >> 8; + + /* This handles only RGB and BGR */ + g = (color->color.green & 0xff00); + if (image->red_mask == 0xf800) + { + r = (color->color.red & 0xff00) << 8; + b = color->color.blue >> 8; + } + else + { + r = color->color.red >> 8; + b = (color->color.blue & 0xff00) << 8; + } + src = (srca << 24) | r | g | b; + + width = xftg->metrics.width; + height = xftg->metrics.height; + + x -= xftg->metrics.x; + y -= xftg->metrics.y; + + dstLine = (CARD16 *) (image->data + image->bytes_per_line * y + (x << 1)); + dstStride = image->bytes_per_line >> 1; + maskLine = (unsigned char *) xftg->bitmap; + maskStride = (width + 3) & ~3; + + while (height--) + { + dst = dstLine; + dstLine += dstStride; + mask = maskLine; + maskLine += maskStride; + w = width; + + while (w--) + { + m = *mask++; + if (m == 0xff) + { + if (srca == 0xff) + d = src; + else + { + d = *dst; + d = fbOver24 (src, cvt0565to8888(d)); + } + *dst = cvt8888to0565(d); + } + else if (m) + { + d = *dst; + d = fbOver24 (fbIn(src,m), cvt0565to8888(d)); + *dst = cvt8888to0565(d); + } + dst++; + } + } +} + +static void +_XftSmoothGlyphGray555 (XImage *image, + _Xconst XftGlyph *xftg, + int x, + int y, + _Xconst XftColor *color) +{ + CARD32 src, srca; + CARD32 r, g, b; + CARD32 d; + CARD16 *dstLine, *dst; + CARD8 *maskLine, *mask, m; + int dstStride, maskStride; + int width, height; + int w; + + srca = color->color.alpha >> 8; + + /* This handles only RGB and BGR */ + g = (color->color.green & 0xff00); + if (image->red_mask == 0xf800) + { + r = (color->color.red & 0xff00) << 8; + b = color->color.blue >> 8; + } + else + { + r = color->color.red >> 8; + b = (color->color.blue & 0xff00) << 8; + } + src = (srca << 24) | r | g | b; + + width = xftg->metrics.width; + height = xftg->metrics.height; + + x -= xftg->metrics.x; + y -= xftg->metrics.y; + + dstLine = (CARD16 *) (image->data + image->bytes_per_line * y + (x << 1)); + dstStride = image->bytes_per_line >> 1; + maskLine = (unsigned char *) xftg->bitmap; + maskStride = (width + 3) & ~3; + + while (height--) + { + dst = dstLine; + dstLine += dstStride; + mask = maskLine; + maskLine += maskStride; + w = width; + + while (w--) + { + m = *mask++; + if (m == 0xff) + { + if (srca == 0xff) + d = src; + else + { + d = *dst; + d = fbOver24 (src, cvt0555to8888(d)); + } + *dst = cvt8888to0555(d); + } + else if (m) + { + d = *dst; + d = fbOver24 (fbIn(src,m), cvt0555to8888(d)); + *dst = cvt8888to0555(d); + } + dst++; + } + } +} + +static void +_XftSmoothGlyphGray (XImage *image, + _Xconst XftGlyph *xftg, + int x, + int y, + _Xconst XftColor *color) +{ + CARD32 src, srca; + int r_shift, r_len; + int g_shift, g_len; + int b_shift, b_len; + CARD8 *maskLine, *mask, m; + int maskStride; + CARD32 d; + unsigned long pixel; + int width, height; + int w, tx; + + srca = color->color.alpha >> 8; + src = (srca << 24 | + (color->color.red & 0xff00) << 8 | + (color->color.green & 0xff00) | + (color->color.blue) >> 8); + x -= xftg->metrics.x; + y -= xftg->metrics.y; + width = xftg->metrics.width; + height = xftg->metrics.height; + + maskLine = (unsigned char *) xftg->bitmap; + maskStride = (width + 3) & ~3; + + _XftExamineBitfield (image->red_mask, &r_shift, &r_len); + _XftExamineBitfield (image->green_mask, &g_shift, &g_len); + _XftExamineBitfield (image->blue_mask, &b_shift, &b_len); + while (height--) + { + mask = maskLine; + maskLine += maskStride; + w = width; + tx = x; + + while (w--) + { + m = *mask++; + if (m == 0xff) + { + if (srca == 0xff) + d = src; + else + { + pixel = XGetPixel (image, tx, y); + d = (_XftGetField (pixel, r_shift, r_len) << 16 | + _XftGetField (pixel, g_shift, g_len) << 8 | + _XftGetField (pixel, b_shift, b_len)); + d = fbOver24 (src, d); + } + pixel = (_XftPutField ((d >> 16) & 0xff, r_shift, r_len) | + _XftPutField ((d >> 8) & 0xff, g_shift, g_len) | + _XftPutField ((d ) & 0xff, b_shift, b_len)); + XPutPixel (image, tx, y, pixel); + } + else if (m) + { + pixel = XGetPixel (image, tx, y); + d = (_XftGetField (pixel, r_shift, r_len) << 16 | + _XftGetField (pixel, g_shift, g_len) << 8 | + _XftGetField (pixel, b_shift, b_len)); + d = fbOver24 (fbIn(src,m), d); + pixel = (_XftPutField ((d >> 16) & 0xff, r_shift, r_len) | + _XftPutField ((d >> 8) & 0xff, g_shift, g_len) | + _XftPutField ((d ) & 0xff, b_shift, b_len)); + XPutPixel (image, tx, y, pixel); + } + tx++; + } + y++; + } +} + +static void +_XftSmoothGlyphRgba (XImage *image, + _Xconst XftGlyph *xftg, + int x, + int y, + _Xconst XftColor *color) +{ + CARD32 src, srca; + int r_shift, r_len; + int g_shift, g_len; + int b_shift, b_len; + CARD32 *mask, ma; + CARD32 d; + unsigned long pixel; + int width, height; + int w, tx; + + srca = color->color.alpha >> 8; + src = (srca << 24 | + (color->color.red & 0xff00) << 8 | + (color->color.green & 0xff00) | + (color->color.blue) >> 8); + x -= xftg->metrics.x; + y -= xftg->metrics.y; + width = xftg->metrics.width; + height = xftg->metrics.height; + + mask = (CARD32 *) xftg->bitmap; + + _XftExamineBitfield (image->red_mask, &r_shift, &r_len); + _XftExamineBitfield (image->green_mask, &g_shift, &g_len); + _XftExamineBitfield (image->blue_mask, &b_shift, &b_len); + while (height--) + { + w = width; + tx = x; + + while (w--) + { + ma = *mask++; + if (ma == 0xffffffff) + { + if (srca == 0xff) + d = src; + else + { + pixel = XGetPixel (image, tx, y); + d = (_XftGetField (pixel, r_shift, r_len) << 16 | + _XftGetField (pixel, g_shift, g_len) << 8 | + _XftGetField (pixel, b_shift, b_len)); + d = fbOver24 (src, d); + } + pixel = (_XftPutField ((d >> 16) & 0xff, r_shift, r_len) | + _XftPutField ((d >> 8) & 0xff, g_shift, g_len) | + _XftPutField ((d ) & 0xff, b_shift, b_len)); + XPutPixel (image, tx, y, pixel); + } + else if (ma) + { + CARD32 m,n,o; + pixel = XGetPixel (image, tx, y); + d = (_XftGetField (pixel, r_shift, r_len) << 16 | + _XftGetField (pixel, g_shift, g_len) << 8 | + _XftGetField (pixel, b_shift, b_len)); +#define XftInOverC(src,srca,msk,dst,i,result) { \ + CARD16 __a = XftGet8(msk,i); \ + CARD32 __t, __ta; \ + CARD32 __i; \ + __t = XftIntMult (XftGet8(src,i), __a,__i); \ + __ta = (CARD8) ~XftIntMult (srca, __a,__i); \ + __t = __t + XftIntMult(XftGet8(dst,i),__ta,__i); \ + __t = (CARD32) (CARD8) (__t | (-(__t >> 8))); \ + result = __t << (i); \ +} + XftInOverC(src,srca,ma,d,0,m); + XftInOverC(src,srca,ma,d,8,n); + XftInOverC(src,srca,ma,d,16,o); + d = m | n | o; + pixel = (_XftPutField ((d >> 16) & 0xff, r_shift, r_len) | + _XftPutField ((d >> 8) & 0xff, g_shift, g_len) | + _XftPutField ((d ) & 0xff, b_shift, b_len)); + XPutPixel (image, tx, y, pixel); + } + tx++; + } + y++; + } +} + +static FcBool +_XftSmoothGlyphPossible (XftDraw *draw) +{ + if (!draw->visual) + return FcFalse; + if (draw->visual->class != TrueColor) + return FcFalse; + return FcTrue; +} + +typedef void (*XftSmoothGlyph) (XImage *image, + _Xconst XftGlyph *xftg, + int x, + int y, + _Xconst XftColor *color); + +static XftSmoothGlyph +_XftSmoothGlyphFind (XftDraw *draw, XftFont *public) +{ + XftFontInt *font = (XftFontInt *) public; + + if (!font->info.antialias) + return _XftSmoothGlyphMono; + else switch (font->info.rgba) { + case FC_RGBA_RGB: + case FC_RGBA_BGR: + case FC_RGBA_VRGB: + case FC_RGBA_VBGR: + return _XftSmoothGlyphRgba; + default: + switch (XftDrawBitsPerPixel (draw)) { + case 32: + if ((draw->visual->red_mask == 0xff0000 && + draw->visual->green_mask == 0x00ff00 && + draw->visual->blue_mask == 0x0000ff) || + (draw->visual->red_mask == 0x0000ff && + draw->visual->green_mask == 0x00ff00 && + draw->visual->blue_mask == 0xff0000)) + { + return _XftSmoothGlyphGray8888; + } + break; + case 16: + if ((draw->visual->red_mask == 0xf800 && + draw->visual->green_mask == 0x07e0 && + draw->visual->blue_mask == 0x001f) || + (draw->visual->red_mask == 0x001f && + draw->visual->green_mask == 0x07e0 && + draw->visual->blue_mask == 0xf800)) + { + return _XftSmoothGlyphGray565; + } + if ((draw->visual->red_mask == 0x7c00 && + draw->visual->green_mask == 0x03e0 && + draw->visual->blue_mask == 0x001f) || + (draw->visual->red_mask == 0x001f && + draw->visual->green_mask == 0x03e0 && + draw->visual->blue_mask == 0x7c00)) + { + return _XftSmoothGlyphGray555; + } + break; + default: + break; + } + return _XftSmoothGlyphGray; + } +} + +static XftGlyph * +_XftGlyphDefault (Display *dpy, XftFont *public) +{ + XftFontInt *font = (XftFontInt *) public; + FT_UInt missing[XFT_NMISSING]; + int nmissing; + FcBool glyphs_loaded = FcFalse; + + if (XftFontCheckGlyph (dpy, public, FcTrue, 0, missing, &nmissing)) + glyphs_loaded = FcTrue; + if (nmissing) + XftFontLoadGlyphs (dpy, public, glyphs_loaded, missing, nmissing); + return font->glyphs[0]; +} + +static int XftGetImageErrorHandler (Display *dpy, XErrorEvent *error_event) +{ + return 0; +} + +_X_HIDDEN void +XftGlyphCore (XftDraw *draw, + _Xconst XftColor *color, + XftFont *public, + int x, + int y, + _Xconst FT_UInt *glyphs, + int nglyphs) +{ + Display *dpy = draw->dpy; + XftFontInt *font = (XftFontInt *) public; + XftGlyph *xftg; + FT_UInt glyph; + _Xconst FT_UInt *g; + FT_UInt missing[XFT_NMISSING]; + FcBool glyphs_loaded; + int nmissing; + int n; + XErrorHandler prev_error; + + /* + * Load missing glyphs + */ + g = glyphs; + n = nglyphs; + nmissing = 0; + glyphs_loaded = FcFalse; + while (n--) + if (XftFontCheckGlyph (dpy, public, FcTrue, *g++, missing, &nmissing)) + glyphs_loaded = FcTrue; + if (nmissing) + XftFontLoadGlyphs (dpy, public, FcTrue, missing, nmissing); + + g = glyphs; + n = nglyphs; + if ((font->info.antialias || color->color.alpha != 0xffff) && + _XftSmoothGlyphPossible (draw)) + { + XGlyphInfo gi; + XImage *image; + unsigned int depth; + int ox, oy; + XftSmoothGlyph smooth = _XftSmoothGlyphFind (draw, public); + + XftGlyphExtents (dpy, public, glyphs, nglyphs, &gi); + if (!gi.width || !gi.height) + goto bail1; + ox = x - gi.x; + oy = y - gi.y; + /* + * Try to get bits directly from the drawable; if that fails, + * use a temporary pixmap. When it does fail, assume it + * will probably fail for a while and keep using temporary + * pixmaps for a while to avoid double round trips. + */ + if (draw->core.use_pixmap == 0) + { + prev_error = XSetErrorHandler (XftGetImageErrorHandler); + image = XGetImage (dpy, draw->drawable, + ox, oy, + gi.width, gi.height, AllPlanes, + ZPixmap); + XSetErrorHandler (prev_error); + if (!image) + draw->core.use_pixmap = XFT_ASSUME_PIXMAP; + } + else + { + draw->core.use_pixmap--; + image = NULL; + } + if (!image && (depth = XftDrawDepth (draw))) + { + Pixmap pix; + GC gc; + XGCValues gcv; + + pix = XCreatePixmap (dpy, draw->drawable, + gi.width, gi.height, depth); + gcv.graphics_exposures = False; + gc = XCreateGC (dpy, pix, GCGraphicsExposures, &gcv); + XCopyArea (dpy, draw->drawable, pix, gc, ox, oy, + gi.width, gi.height, 0, 0); + XFreeGC (dpy, gc); + image = XGetImage (dpy, pix, 0, 0, gi.width, gi.height, AllPlanes, + ZPixmap); + XFreePixmap (dpy, pix); + } + if (!image) + goto bail1; + image->red_mask = draw->visual->red_mask; + image->green_mask = draw->visual->green_mask; + image->blue_mask = draw->visual->blue_mask; + if (image->byte_order != XftNativeByteOrder ()) + XftSwapImage (image); + while (n--) + { + glyph = *g++; + if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph])) + xftg = _XftGlyphDefault (dpy, public); + if (xftg) + { + (*smooth) (image, xftg, x - ox, y - oy, color); + x += xftg->metrics.xOff; + y += xftg->metrics.yOff; + } + } + if (image->byte_order != XftNativeByteOrder ()) + XftSwapImage (image); + XPutImage (dpy, draw->drawable, draw->core.gc, image, 0, 0, ox, oy, + gi.width, gi.height); + XDestroyImage (image); + } + else + { + XftSharpGlyph sharp = _XftSharpGlyphFind (draw, public); + while (n--) + { + glyph = *g++; + if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph])) + xftg = _XftGlyphDefault (dpy, public); + if (xftg) + { + (*sharp) (draw, xftg, x, y); + x += xftg->metrics.xOff; + y += xftg->metrics.yOff; + } + } + } +bail1: + if (glyphs_loaded) + _XftFontManageMemory (dpy, public); +} + +#define NUM_LOCAL 1024 + +_X_HIDDEN void +XftGlyphSpecCore (XftDraw *draw, + _Xconst XftColor *color, + XftFont *public, + _Xconst XftGlyphSpec *glyphs, + int nglyphs) +{ + Display *dpy = draw->dpy; + XftFontInt *font = (XftFontInt *) public; + XftGlyph *xftg; + FT_UInt missing[XFT_NMISSING]; + FcBool glyphs_loaded; + int nmissing; + int i; + XErrorHandler prev_error; + int x1, y1, x2, y2; + + /* + * Load missing glyphs + */ + glyphs_loaded = FcFalse; + x1 = y1 = x2 = y2 = 0; + for (i = 0; i < nglyphs; i++) + { + XGlyphInfo gi; + int g_x1, g_x2, g_y1, g_y2; + + nmissing = 0; + if (XftFontCheckGlyph (dpy, public, FcTrue, glyphs[i].glyph, missing, &nmissing)) + glyphs_loaded = FcTrue; + if (nmissing) + XftFontLoadGlyphs (dpy, public, FcTrue, missing, nmissing); + + XftGlyphExtents (dpy, public, &glyphs[i].glyph, 1, &gi); + g_x1 = glyphs[i].x - gi.x; + g_y1 = glyphs[i].y - gi.y; + g_x2 = g_x1 + gi.width; + g_y2 = g_y1 + gi.height; + if (i) + { + if (g_x1 < x1) + x1 = g_x1; + if (g_y1 < y1) + y1 = g_y1; + if (g_x2 > x2) + x2 = g_x2; + if (g_y2 > y2) + y2 = g_y2; + } + else + { + x1 = g_x1; + y1 = g_y1; + x2 = g_x2; + y2 = g_y2; + } + } + + if (x1 == x2 || y1 == y2) + goto bail1; + + if ((font->info.antialias || color->color.alpha != 0xffff) && + _XftSmoothGlyphPossible (draw)) + { + XImage *image; + unsigned int depth; + int width = x2 - x1, height = y2 - y1; + XftSmoothGlyph smooth = _XftSmoothGlyphFind (draw, public); + + /* + * Try to get bits directly from the drawable; if that fails, + * use a temporary pixmap. When it does fail, assume it + * will probably fail for a while and keep using temporary + * pixmaps for a while to avoid double round trips. + */ + if (draw->core.use_pixmap == 0) + { + prev_error = XSetErrorHandler (XftGetImageErrorHandler); + image = XGetImage (dpy, draw->drawable, + x1, y1, + width, height, AllPlanes, + ZPixmap); + XSetErrorHandler (prev_error); + if (!image) + draw->core.use_pixmap = XFT_ASSUME_PIXMAP; + } + else + { + draw->core.use_pixmap--; + image = NULL; + } + if (!image && (depth = XftDrawDepth (draw))) + { + Pixmap pix; + GC gc; + XGCValues gcv; + + pix = XCreatePixmap (dpy, draw->drawable, + width, height, depth); + gcv.graphics_exposures = False; + gc = XCreateGC (dpy, pix, GCGraphicsExposures, &gcv); + XCopyArea (dpy, draw->drawable, pix, gc, x1, y1, + width, height, 0, 0); + XFreeGC (dpy, gc); + image = XGetImage (dpy, pix, 0, 0, width, height, AllPlanes, + ZPixmap); + XFreePixmap (dpy, pix); + } + if (!image) + goto bail1; + image->red_mask = draw->visual->red_mask; + image->green_mask = draw->visual->green_mask; + image->blue_mask = draw->visual->blue_mask; + if (image->byte_order != XftNativeByteOrder ()) + XftSwapImage (image); + for (i = 0; i < nglyphs; i++) + { + FT_UInt glyph = glyphs[i].glyph; + if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph])) + xftg = _XftGlyphDefault (dpy, public); + if (xftg) + { + (*smooth) (image, xftg, glyphs[i].x - x1, + glyphs[i].y - y1, color); + } + } + if (image->byte_order != XftNativeByteOrder ()) + XftSwapImage (image); + XPutImage (dpy, draw->drawable, draw->core.gc, image, 0, 0, x1, y1, + width, height); + XDestroyImage (image); + } + else + { + XftSharpGlyph sharp = _XftSharpGlyphFind (draw, public); + for (i = 0; i < nglyphs; i++) + { + FT_UInt glyph = glyphs[i].glyph; + if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph])) + xftg = _XftGlyphDefault (dpy, public); + if (xftg) + (*sharp) (draw, xftg, glyphs[i].x, glyphs[i].y); + } + } +bail1: + if (glyphs_loaded) + _XftFontManageMemory (dpy, public); +} + +_X_HIDDEN void +XftGlyphFontSpecCore (XftDraw *draw, + _Xconst XftColor *color, + _Xconst XftGlyphFontSpec *glyphs, + int nglyphs) +{ + Display *dpy = draw->dpy; + XftGlyph *xftg; + FT_UInt missing[XFT_NMISSING]; + FcBool glyphs_loaded; + int nmissing; + int i; + XErrorHandler prev_error; + int x1, y1, x2, y2; + + /* + * Load missing glyphs + */ + glyphs_loaded = FcFalse; + x1 = y1 = x2 = y2 = 0; + for (i = 0; i < nglyphs; i++) + { + XftFont *public = glyphs[i].font; + XGlyphInfo gi; + int g_x1, g_x2, g_y1, g_y2; + + nmissing = 0; + if (XftFontCheckGlyph (dpy, public, FcTrue, glyphs[i].glyph, missing, &nmissing)) + glyphs_loaded = FcTrue; + if (nmissing) + XftFontLoadGlyphs (dpy, public, FcTrue, missing, nmissing); + + XftGlyphExtents (dpy, public, &glyphs[i].glyph, 1, &gi); + g_x1 = glyphs[i].x - gi.x; + g_y1 = glyphs[i].y - gi.y; + g_x2 = g_x1 + gi.width; + g_y2 = g_y1 + gi.height; + if (i) + { + if (g_x1 < x1) + x1 = g_x1; + if (g_y1 < y1) + y1 = g_y1; + if (g_x2 > x2) + x2 = g_x2; + if (g_y2 > y2) + y2 = g_y2; + } + else + { + x1 = g_x1; + y1 = g_y1; + x2 = g_x2; + y2 = g_y2; + } + } + + if (x1 == x2 || y1 == y2) + goto bail1; + + for (i = 0; i < nglyphs; i++) + if (((XftFontInt *) glyphs[i].font)->info.antialias) + break; + + if ((i != nglyphs || color->color.alpha != 0xffff) && + _XftSmoothGlyphPossible (draw)) + { + XImage *image; + unsigned int depth; + int width = x2 - x1, height = y2 - y1; + + /* + * Try to get bits directly from the drawable; if that fails, + * use a temporary pixmap. When it does fail, assume it + * will probably fail for a while and keep using temporary + * pixmaps for a while to avoid double round trips. + */ + if (draw->core.use_pixmap == 0) + { + prev_error = XSetErrorHandler (XftGetImageErrorHandler); + image = XGetImage (dpy, draw->drawable, + x1, y1, + width, height, AllPlanes, + ZPixmap); + XSetErrorHandler (prev_error); + if (!image) + draw->core.use_pixmap = XFT_ASSUME_PIXMAP; + } + else + { + draw->core.use_pixmap--; + image = NULL; + } + if (!image && (depth = XftDrawDepth (draw))) + { + Pixmap pix; + GC gc; + XGCValues gcv; + + pix = XCreatePixmap (dpy, draw->drawable, + width, height, depth); + gcv.graphics_exposures = False; + gc = XCreateGC (dpy, pix, GCGraphicsExposures, &gcv); + XCopyArea (dpy, draw->drawable, pix, gc, x1, y1, + width, height, 0, 0); + XFreeGC (dpy, gc); + image = XGetImage (dpy, pix, 0, 0, width, height, AllPlanes, + ZPixmap); + XFreePixmap (dpy, pix); + } + if (!image) + goto bail1; + image->red_mask = draw->visual->red_mask; + image->green_mask = draw->visual->green_mask; + image->blue_mask = draw->visual->blue_mask; + if (image->byte_order != XftNativeByteOrder ()) + XftSwapImage (image); + for (i = 0; i < nglyphs; i++) + { + XftFont *public = glyphs[i].font; + XftFontInt *font = (XftFontInt *) public; + XftSmoothGlyph smooth = _XftSmoothGlyphFind (draw, public); + FT_UInt glyph = glyphs[i].glyph; + + if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph])) + xftg = _XftGlyphDefault (dpy, public); + if (xftg) + { + (*smooth) (image, xftg, glyphs[i].x - x1, + glyphs[i].y - y1, color); + } + } + if (image->byte_order != XftNativeByteOrder ()) + XftSwapImage (image); + XPutImage (dpy, draw->drawable, draw->core.gc, image, 0, 0, x1, y1, + width, height); + XDestroyImage (image); + } + else + { + for (i = 0; i < nglyphs; i++) + { + XftFont *public = glyphs[i].font; + XftFontInt *font = (XftFontInt *) public; + XftSharpGlyph sharp = _XftSharpGlyphFind (draw, public); + FT_UInt glyph = glyphs[i].glyph; + + if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph])) + xftg = _XftGlyphDefault (dpy, public); + if (xftg) + (*sharp) (draw, xftg, glyphs[i].x, glyphs[i].y); + } + } +bail1: + if (glyphs_loaded) + for (i = 0; i < nglyphs; i++) + _XftFontManageMemory (dpy, glyphs[i].font); +} diff --git a/libXft/src/xftdbg.c b/libXft/src/xftdbg.c new file mode 100644 index 000000000..4c4b078d0 --- /dev/null +++ b/libXft/src/xftdbg.c @@ -0,0 +1,46 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +_X_HIDDEN int +XftDebug (void) +{ + static int initialized; + static int debug; + + if (!initialized) + { + char *e; + + initialized = 1; + e = getenv ("XFT_DEBUG"); + if (e) + { + printf ("XFT_DEBUG=%s\n", e); + debug = atoi (e); + if (debug <= 0) + debug = 1; + } + } + return debug; +} diff --git a/libXft/src/xftdpy.c b/libXft/src/xftdpy.c new file mode 100644 index 000000000..055351586 --- /dev/null +++ b/libXft/src/xftdpy.c @@ -0,0 +1,552 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +_X_HIDDEN XftDisplayInfo *_XftDisplayInfo; + +static int +_XftCloseDisplay (Display *dpy, XExtCodes *codes) +{ + XftDisplayInfo *info, **prev; + + info = _XftDisplayInfoGet (dpy, FcFalse); + if (!info) + return 0; + + /* + * Get rid of any dangling unreferenced fonts + */ + info->max_unref_fonts = 0; + XftFontManageMemory (dpy); + + /* + * Clean up the default values + */ + if (info->defaults) + FcPatternDestroy (info->defaults); + + /* + * Unhook from the global list + */ + for (prev = &_XftDisplayInfo; (info = *prev); prev = &(*prev)->next) + if (info->display == dpy) + break; + *prev = info->next; + + free (info); + return 0; +} + + +_X_HIDDEN XftDisplayInfo * +_XftDisplayInfoGet (Display *dpy, FcBool createIfNecessary) +{ + XftDisplayInfo *info, **prev; + XRenderPictFormat pf; + int i; + int event_base, error_base; + + for (prev = &_XftDisplayInfo; (info = *prev); prev = &(*prev)->next) + { + if (info->display == dpy) + { + /* + * MRU the list + */ + if (prev != &_XftDisplayInfo) + { + *prev = info->next; + info->next = _XftDisplayInfo; + _XftDisplayInfo = info; + } + return info; + } + } + if (!createIfNecessary) + return NULL; + + info = (XftDisplayInfo *) malloc (sizeof (XftDisplayInfo)); + if (!info) + goto bail0; + info->codes = XAddExtension (dpy); + if (!info->codes) + goto bail1; + (void) XESetCloseDisplay (dpy, info->codes->extension, _XftCloseDisplay); + + info->display = dpy; + info->defaults = NULL; + info->solidFormat = NULL; + info->hasRender = (XRenderQueryExtension (dpy, &event_base, &error_base) && + (XRenderFindVisualFormat (dpy, DefaultVisual (dpy, DefaultScreen (dpy))) != NULL)); + info->use_free_glyphs = FcTrue; + if (info->hasRender) + { + int major, minor; + XRenderQueryVersion (dpy, &major, &minor); + if (major < 0 || (major == 0 && minor <= 2)) + info->use_free_glyphs = FcFalse; + + pf.type = PictTypeDirect; + pf.depth = 32; + pf.direct.redMask = 0xff; + pf.direct.greenMask = 0xff; + pf.direct.blueMask = 0xff; + pf.direct.alphaMask = 0xff; + info->solidFormat = XRenderFindFormat (dpy, + (PictFormatType| + PictFormatDepth| + PictFormatRedMask| + PictFormatGreenMask| + PictFormatBlueMask| + PictFormatAlphaMask), + &pf, + 0); + } + if (XftDebug () & XFT_DBG_RENDER) + { + Visual *visual = DefaultVisual (dpy, DefaultScreen (dpy)); + XRenderPictFormat *format = XRenderFindVisualFormat (dpy, visual); + + printf ("XftDisplayInfoGet Default visual 0x%x ", + (int) visual->visualid); + if (format) + { + if (format->type == PictTypeDirect) + { + printf ("format %d,%d,%d,%d\n", + format->direct.alpha, + format->direct.red, + format->direct.green, + format->direct.blue); + } + else + { + printf ("format indexed\n"); + } + } + else + printf ("No Render format for default visual\n"); + + printf ("XftDisplayInfoGet initialized, hasRender set to \"%s\"\n", + info->hasRender ? "True" : "False"); + } + for (i = 0; i < XFT_NUM_SOLID_COLOR; i++) + { + info->colors[i].screen = -1; + info->colors[i].pict = 0; + } + info->fonts = NULL; + + info->next = _XftDisplayInfo; + _XftDisplayInfo = info; + + info->glyph_memory = NULL; + info->max_glyph_memory = XftDefaultGetInteger (dpy, + XFT_MAX_GLYPH_MEMORY, 0, + XFT_DPY_MAX_GLYPH_MEMORY); + if (XftDebug () & XFT_DBG_CACHE) + printf ("global max cache memory %ld\n", info->max_glyph_memory); + + + info->num_unref_fonts = 0; + info->max_unref_fonts = XftDefaultGetInteger (dpy, + XFT_MAX_UNREF_FONTS, 0, + XFT_DPY_MAX_UNREF_FONTS); + if (XftDebug() & XFT_DBG_CACHE) + printf ("global max unref fonts %d\n", info->max_unref_fonts); + + memset (info->fontHash, '\0', sizeof (XftFont *) * XFT_NUM_FONT_HASH); + return info; + +bail1: + free (info); +bail0: + if (XftDebug () & XFT_DBG_RENDER) + { + printf ("XftDisplayInfoGet failed to initialize, Xft unhappy\n"); + } + return NULL; +} + +/* + * Reduce memory usage in X server + */ + +static void +_XftDisplayValidateMemory (XftDisplayInfo *info) +{ + XftFont *public; + XftFontInt *font; + unsigned long glyph_memory; + + glyph_memory = 0; + for (public = info->fonts; public; public = font->next) + { + font = (XftFontInt *) public; + glyph_memory += font->glyph_memory; + } + if (glyph_memory != info->glyph_memory) + printf ("Display glyph cache incorrect has %ld bytes, should have %ld\n", + info->glyph_memory, glyph_memory); +} + +_X_HIDDEN void +_XftDisplayManageMemory (Display *dpy) +{ + XftDisplayInfo *info = _XftDisplayInfoGet (dpy, False); + unsigned long glyph_memory; + XftFont *public; + XftFontInt *font; + + if (!info || !info->max_glyph_memory) + return; + if (XftDebug () & XFT_DBG_CACHE) + { + if (info->glyph_memory > info->max_glyph_memory) + printf ("Reduce global memory from %ld to %ld\n", + info->glyph_memory, info->max_glyph_memory); + _XftDisplayValidateMemory (info); + } + while (info->glyph_memory > info->max_glyph_memory) + { + glyph_memory = rand () % info->glyph_memory; + public = info->fonts; + while (public) + { + font = (XftFontInt *) public; + + if (font->glyph_memory > glyph_memory) + { + _XftFontUncacheGlyph (dpy, public); + break; + } + public = font->next; + glyph_memory -= font->glyph_memory; + } + } + if (XftDebug () & XFT_DBG_CACHE) + _XftDisplayValidateMemory (info); +} + +_X_EXPORT Bool +XftDefaultHasRender (Display *dpy) +{ + XftDisplayInfo *info = _XftDisplayInfoGet (dpy, True); + + if (!info) + return False; + return info->hasRender; +} + +_X_EXPORT Bool +XftDefaultSet (Display *dpy, FcPattern *defaults) +{ + XftDisplayInfo *info = _XftDisplayInfoGet (dpy, True); + + if (!info) + return False; + if (info->defaults) + FcPatternDestroy (info->defaults); + info->defaults = defaults; + if (!info->max_glyph_memory) + info->max_glyph_memory = XFT_DPY_MAX_GLYPH_MEMORY; + info->max_glyph_memory = XftDefaultGetInteger (dpy, + XFT_MAX_GLYPH_MEMORY, 0, + info->max_glyph_memory); + if (!info->max_unref_fonts) + info->max_unref_fonts = XFT_DPY_MAX_UNREF_FONTS; + info->max_unref_fonts = XftDefaultGetInteger (dpy, + XFT_MAX_UNREF_FONTS, 0, + info->max_unref_fonts); + return True; +} + +_X_HIDDEN int +XftDefaultParseBool (char *v) +{ + char c0, c1; + + c0 = *v; + if (isupper ((int)c0)) + c0 = tolower (c0); + if (c0 == 't' || c0 == 'y' || c0 == '1') + return 1; + if (c0 == 'f' || c0 == 'n' || c0 == '0') + return 0; + if (c0 == 'o') + { + c1 = v[1]; + if (isupper ((int)c1)) + c1 = tolower (c1); + if (c1 == 'n') + return 1; + if (c1 == 'f') + return 0; + } + return -1; +} + +static Bool +_XftDefaultInitBool (Display *dpy, FcPattern *pat, char *option) +{ + char *v; + int i; + + v = XGetDefault (dpy, "Xft", option); + if (v && (i = XftDefaultParseBool (v)) >= 0) + return FcPatternAddBool (pat, option, i != 0); + return True; +} + +static Bool +_XftDefaultInitDouble (Display *dpy, FcPattern *pat, char *option) +{ + char *v, *e; + double d; + + v = XGetDefault (dpy, "Xft", option); + if (v) + { + d = strtod (v, &e); + if (e != v) + return FcPatternAddDouble (pat, option, d); + } + return True; +} + +static Bool +_XftDefaultInitInteger (Display *dpy, FcPattern *pat, char *option) +{ + char *v, *e; + int i; + + v = XGetDefault (dpy, "Xft", option); + if (v) + { + if (FcNameConstant ((FcChar8 *) v, &i)) + return FcPatternAddInteger (pat, option, i); + i = strtol (v, &e, 0); + if (e != v) + return FcPatternAddInteger (pat, option, i); + } + return True; +} + +static FcPattern * +_XftDefaultInit (Display *dpy) +{ + FcPattern *pat; + + pat = FcPatternCreate (); + if (!pat) + goto bail0; + + if (!_XftDefaultInitDouble (dpy, pat, FC_SCALE)) + goto bail1; + if (!_XftDefaultInitDouble (dpy, pat, FC_DPI)) + goto bail1; + if (!_XftDefaultInitBool (dpy, pat, XFT_RENDER)) + goto bail1; + if (!_XftDefaultInitInteger (dpy, pat, FC_RGBA)) + goto bail1; + if (!_XftDefaultInitBool (dpy, pat, FC_ANTIALIAS)) + goto bail1; +#ifdef FC_EMBOLDEN + if (!_XftDefaultInitBool (dpy, pat, FC_EMBOLDEN)) + goto bail1; +#endif + if (!_XftDefaultInitBool (dpy, pat, FC_AUTOHINT)) + goto bail1; +#ifdef FC_HINT_STYLE + if (!_XftDefaultInitInteger (dpy, pat, FC_HINT_STYLE)) + goto bail1; +#endif + if (!_XftDefaultInitBool (dpy, pat, FC_HINTING)) + goto bail1; + if (!_XftDefaultInitBool (dpy, pat, FC_MINSPACE)) + goto bail1; + if (!_XftDefaultInitInteger (dpy, pat, XFT_MAX_GLYPH_MEMORY)) + goto bail1; + + return pat; + +bail1: + FcPatternDestroy (pat); +bail0: + return NULL; +} + +static FcResult +_XftDefaultGet (Display *dpy, const char *object, int screen, FcValue *v) +{ + XftDisplayInfo *info = _XftDisplayInfoGet (dpy, True); + FcResult r; + + if (!info) + return FcResultNoMatch; + + if (!info->defaults) + { + info->defaults = _XftDefaultInit (dpy); + if (!info->defaults) + return FcResultNoMatch; + } + r = FcPatternGet (info->defaults, object, screen, v); + if (r == FcResultNoId && screen > 0) + r = FcPatternGet (info->defaults, object, 0, v); + return r; +} + +_X_HIDDEN Bool +XftDefaultGetBool (Display *dpy, const char *object, int screen, Bool def) +{ + FcResult r; + FcValue v; + + r = _XftDefaultGet (dpy, object, screen, &v); + if (r != FcResultMatch || v.type != FcTypeBool) + return def; + return v.u.b; +} + +_X_HIDDEN int +XftDefaultGetInteger (Display *dpy, const char *object, int screen, int def) +{ + FcResult r; + FcValue v; + + r = _XftDefaultGet (dpy, object, screen, &v); + if (r != FcResultMatch || v.type != FcTypeInteger) + return def; + return v.u.i; +} + +_X_HIDDEN double +XftDefaultGetDouble (Display *dpy, const char *object, int screen, double def) +{ + FcResult r; + FcValue v; + + r = _XftDefaultGet (dpy, object, screen, &v); + if (r != FcResultMatch || v.type != FcTypeDouble) + return def; + return v.u.d; +} + +_X_EXPORT void +XftDefaultSubstitute (Display *dpy, int screen, FcPattern *pattern) +{ + FcValue v; + double dpi; + + if (FcPatternGet (pattern, XFT_RENDER, 0, &v) == FcResultNoMatch) + { + FcPatternAddBool (pattern, XFT_RENDER, + XftDefaultGetBool (dpy, XFT_RENDER, screen, + XftDefaultHasRender (dpy))); + } + if (FcPatternGet (pattern, FC_ANTIALIAS, 0, &v) == FcResultNoMatch) + { + FcPatternAddBool (pattern, FC_ANTIALIAS, + XftDefaultGetBool (dpy, FC_ANTIALIAS, screen, + True)); + } +#ifdef FC_EMBOLDEN + if (FcPatternGet (pattern, FC_EMBOLDEN, 0, &v) == FcResultNoMatch) + { + FcPatternAddBool (pattern, FC_EMBOLDEN, + XftDefaultGetBool (dpy, FC_EMBOLDEN, screen, + False)); + } +#endif + if (FcPatternGet (pattern, FC_HINTING, 0, &v) == FcResultNoMatch) + { + FcPatternAddBool (pattern, FC_HINTING, + XftDefaultGetBool (dpy, FC_HINTING, screen, + True)); + } +#ifdef FC_HINT_STYLE + if (FcPatternGet (pattern, FC_HINT_STYLE, 0, &v) == FcResultNoMatch) + { + FcPatternAddInteger (pattern, FC_HINT_STYLE, + XftDefaultGetInteger (dpy, FC_HINT_STYLE, screen, + FC_HINT_FULL)); + } +#endif + if (FcPatternGet (pattern, FC_AUTOHINT, 0, &v) == FcResultNoMatch) + { + FcPatternAddBool (pattern, FC_AUTOHINT, + XftDefaultGetBool (dpy, FC_AUTOHINT, screen, + False)); + } + if (FcPatternGet (pattern, FC_RGBA, 0, &v) == FcResultNoMatch) + { + int subpixel = FC_RGBA_UNKNOWN; +#if RENDER_MAJOR > 0 || RENDER_MINOR >= 6 + if (XftDefaultHasRender (dpy)) + { + int render_order = XRenderQuerySubpixelOrder (dpy, screen); + switch (render_order) { + default: + case SubPixelUnknown: subpixel = FC_RGBA_UNKNOWN; break; + case SubPixelHorizontalRGB: subpixel = FC_RGBA_RGB; break; + case SubPixelHorizontalBGR: subpixel = FC_RGBA_BGR; break; + case SubPixelVerticalRGB: subpixel = FC_RGBA_VRGB; break; + case SubPixelVerticalBGR: subpixel = FC_RGBA_VBGR; break; + case SubPixelNone: subpixel = FC_RGBA_NONE; break; + } + } +#endif + FcPatternAddInteger (pattern, FC_RGBA, + XftDefaultGetInteger (dpy, FC_RGBA, screen, + subpixel)); + } + if (FcPatternGet (pattern, FC_MINSPACE, 0, &v) == FcResultNoMatch) + { + FcPatternAddBool (pattern, FC_MINSPACE, + XftDefaultGetBool (dpy, FC_MINSPACE, screen, + False)); + } + if (FcPatternGet (pattern, FC_DPI, 0, &v) == FcResultNoMatch) + { + dpi = (((double) DisplayHeight (dpy, screen) * 25.4) / + (double) DisplayHeightMM (dpy, screen)); + FcPatternAddDouble (pattern, FC_DPI, + XftDefaultGetDouble (dpy, FC_DPI, screen, + dpi)); + } + if (FcPatternGet (pattern, FC_SCALE, 0, &v) == FcResultNoMatch) + { + FcPatternAddDouble (pattern, FC_SCALE, + XftDefaultGetDouble (dpy, FC_SCALE, screen, 1.0)); + } + if (FcPatternGet (pattern, XFT_MAX_GLYPH_MEMORY, 0, &v) == FcResultNoMatch) + { + FcPatternAddInteger (pattern, XFT_MAX_GLYPH_MEMORY, + XftDefaultGetInteger (dpy, XFT_MAX_GLYPH_MEMORY, + screen, + XFT_FONT_MAX_GLYPH_MEMORY)); + } + FcDefaultSubstitute (pattern); +} + diff --git a/libXft/src/xftdraw.c b/libXft/src/xftdraw.c new file mode 100644 index 000000000..ab5174973 --- /dev/null +++ b/libXft/src/xftdraw.c @@ -0,0 +1,994 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +/* + * Ok, this is a pain. To share source pictures across multiple destinations, + * the screen for each drawable must be discovered. + */ + +static int +_XftDrawScreen (Display *dpy, Drawable drawable, Visual *visual) +{ + int s; + Window root; + int x, y; + unsigned int width, height, borderWidth, depth; + /* Special case the most common environment */ + if (ScreenCount (dpy) == 1) + return 0; + /* + * If we've got a visual, look for the screen that points at it. + * This requires no round trip. + */ + if (visual) + { + for (s = 0; s < ScreenCount (dpy); s++) + { + XVisualInfo template, *ret; + int nret; + + template.visualid = visual->visualid; + template.screen = s; + ret = XGetVisualInfo (dpy, VisualIDMask|VisualScreenMask, + &template, &nret); + if (ret) + { + XFree (ret); + return s; + } + } + } + /* + * Otherwise, as the server for the drawable geometry and find + * the screen from the root window. + * This takes a round trip. + */ + if (XGetGeometry (dpy, drawable, &root, &x, &y, &width, &height, + &borderWidth, &depth)) + { + for (s = 0; s < ScreenCount (dpy); s++) + { + if (RootWindow (dpy, s) == root) + return s; + } + } + /* + * Make a guess -- it's probably wrong, but then the app probably + * handed us a bogus drawable in this case + */ + return 0; +} + +_X_HIDDEN unsigned int +XftDrawDepth (XftDraw *draw) +{ + if (!draw->depth) + { + Window root; + int x, y; + unsigned int width, height, borderWidth, depth; + if (XGetGeometry (draw->dpy, draw->drawable, + &root, &x, &y, &width, &height, + &borderWidth, &depth)) + draw->depth = depth; + } + return draw->depth; +} + +_X_HIDDEN unsigned int +XftDrawBitsPerPixel (XftDraw *draw) +{ + if (!draw->bits_per_pixel) + { + XPixmapFormatValues *formats; + int nformats; + unsigned int depth; + + if ((depth = XftDrawDepth (draw)) && + (formats = XListPixmapFormats (draw->dpy, &nformats))) + { + int i; + + for (i = 0; i < nformats; i++) + { + if (formats[i].depth == depth) + { + draw->bits_per_pixel = formats[i].bits_per_pixel; + break; + } + } + XFree (formats); + } + } + return draw->bits_per_pixel; +} + +_X_EXPORT XftDraw * +XftDrawCreate (Display *dpy, + Drawable drawable, + Visual *visual, + Colormap colormap) +{ + XftDraw *draw; + + draw = (XftDraw *) malloc (sizeof (XftDraw)); + if (!draw) + return NULL; + + draw->dpy = dpy; + draw->drawable = drawable; + draw->screen = _XftDrawScreen (dpy, drawable, visual); + draw->depth = 0; /* don't find out unless we need to know */ + draw->bits_per_pixel = 0; /* don't find out unless we need to know */ + draw->visual = visual; + draw->colormap = colormap; + draw->render.pict = 0; + draw->core.gc = NULL; + draw->core.use_pixmap = 0; + draw->clip_type = XftClipTypeNone; + draw->subwindow_mode = ClipByChildren; + XftMemAlloc (XFT_MEM_DRAW, sizeof (XftDraw)); + return draw; +} + +_X_EXPORT XftDraw * +XftDrawCreateBitmap (Display *dpy, + Pixmap bitmap) +{ + XftDraw *draw; + + draw = (XftDraw *) malloc (sizeof (XftDraw)); + if (!draw) + return NULL; + draw->dpy = dpy; + draw->drawable = (Drawable) bitmap; + draw->screen = _XftDrawScreen (dpy, bitmap, NULL); + draw->depth = 1; + draw->bits_per_pixel = 1; + draw->visual = NULL; + draw->colormap = 0; + draw->render.pict = 0; + draw->core.gc = NULL; + draw->core.use_pixmap = 0; + draw->clip_type = XftClipTypeNone; + draw->subwindow_mode = ClipByChildren; + XftMemAlloc (XFT_MEM_DRAW, sizeof (XftDraw)); + return draw; +} + +_X_EXPORT XftDraw * +XftDrawCreateAlpha (Display *dpy, + Pixmap pixmap, + int depth) +{ + XftDraw *draw; + + draw = (XftDraw *) malloc (sizeof (XftDraw)); + if (!draw) + return NULL; + draw->dpy = dpy; + draw->drawable = (Drawable) pixmap; + draw->screen = _XftDrawScreen (dpy, pixmap, NULL); + draw->depth = depth; + draw->bits_per_pixel = 0; /* don't find out until we need it */ + draw->visual = NULL; + draw->colormap = 0; + draw->render.pict = 0; + draw->core.gc = NULL; + draw->core.use_pixmap = 0; + draw->clip_type = XftClipTypeNone; + draw->subwindow_mode = ClipByChildren; + XftMemAlloc (XFT_MEM_DRAW, sizeof (XftDraw)); + return draw; +} + +static XRenderPictFormat * +_XftDrawFormat (XftDraw *draw) +{ + XftDisplayInfo *info = _XftDisplayInfoGet (draw->dpy, True); + + if (!info || !info->hasRender) + return NULL; + + if (draw->visual == NULL) + { + XRenderPictFormat pf; + + pf.type = PictTypeDirect; + pf.depth = XftDrawDepth (draw); + pf.direct.alpha = 0; + pf.direct.alphaMask = (1 << pf.depth) - 1; + return XRenderFindFormat (draw->dpy, + (PictFormatType| + PictFormatDepth| + PictFormatAlpha| + PictFormatAlphaMask), + &pf, + 0); + } + else + return XRenderFindVisualFormat (draw->dpy, draw->visual); +} + +_X_EXPORT void +XftDrawChange (XftDraw *draw, + Drawable drawable) +{ + draw->drawable = drawable; + if (draw->render.pict) + { + XRenderFreePicture (draw->dpy, draw->render.pict); + draw->render.pict = 0; + } + if (draw->core.gc) + { + XFreeGC (draw->dpy, draw->core.gc); + draw->core.gc = NULL; + } +} + +_X_EXPORT Display * +XftDrawDisplay (XftDraw *draw) +{ + return draw->dpy; +} + +_X_EXPORT Drawable +XftDrawDrawable (XftDraw *draw) +{ + return draw->drawable; +} + +_X_EXPORT Colormap +XftDrawColormap (XftDraw *draw) +{ + return draw->colormap; +} + +_X_EXPORT Visual * +XftDrawVisual (XftDraw *draw) +{ + return draw->visual; +} + +_X_EXPORT void +XftDrawDestroy (XftDraw *draw) +{ + if (draw->render.pict) + XRenderFreePicture (draw->dpy, draw->render.pict); + if (draw->core.gc) + XFreeGC (draw->dpy, draw->core.gc); + switch (draw->clip_type) { + case XftClipTypeRegion: + XDestroyRegion (draw->clip.region); + break; + case XftClipTypeRectangles: + free (draw->clip.rect); + break; + case XftClipTypeNone: + break; + } + XftMemFree (XFT_MEM_DRAW, sizeof (XftDraw)); + free (draw); +} + +_X_EXPORT Picture +XftDrawSrcPicture (XftDraw *draw, _Xconst XftColor *color) +{ + Display *dpy = draw->dpy; + XftDisplayInfo *info = _XftDisplayInfoGet (dpy, True); + int i; + XftColor bitmapColor; + + if (!info) + return 0; + + /* + * Monochrome targets require special handling; the PictOp controls + * the color, and the color must be opaque + */ + if (!draw->visual && draw->depth == 1) + { + bitmapColor.color.alpha = 0xffff; + bitmapColor.color.red = 0xffff; + bitmapColor.color.green = 0xffff; + bitmapColor.color.blue = 0xffff; + color = &bitmapColor; + } + + /* + * See if there's one already available + */ + for (i = 0; i < XFT_NUM_SOLID_COLOR; i++) + { + if (info->colors[i].pict && + info->colors[i].screen == draw->screen && + !memcmp ((void *) &color->color, + (void *) &info->colors[i].color, + sizeof (XRenderColor))) + return info->colors[i].pict; + } + /* + * Pick one to replace at random + */ + i = (unsigned int) rand () % XFT_NUM_SOLID_COLOR; + /* + * Recreate if it was for the wrong screen + */ + if (info->colors[i].screen != draw->screen && info->colors[i].pict) + { + XRenderFreePicture (dpy, info->colors[i].pict); + info->colors[i].pict = 0; + } + /* + * Create picture if necessary + */ + if (!info->colors[i].pict) + { + Pixmap pix; + XRenderPictureAttributes pa; + + pix = XCreatePixmap (dpy, RootWindow (dpy, draw->screen), 1, 1, + info->solidFormat->depth); + pa.repeat = True; + info->colors[i].pict = XRenderCreatePicture (draw->dpy, + pix, + info->solidFormat, + CPRepeat, &pa); + XFreePixmap (dpy, pix); + } + /* + * Set to the new color + */ + info->colors[i].color = color->color; + info->colors[i].screen = draw->screen; + XRenderFillRectangle (dpy, PictOpSrc, + info->colors[i].pict, + &color->color, 0, 0, 1, 1); + return info->colors[i].pict; +} + +static int +_XftDrawOp (_Xconst XftDraw *draw, _Xconst XftColor *color) +{ + if (draw->visual || draw->depth != 1) + return PictOpOver; + if (color->color.alpha >= 0x8000) + return PictOpOver; + return PictOpOutReverse; +} + +static FcBool +_XftDrawRenderPrepare (XftDraw *draw) +{ + if (!draw->render.pict) + { + XRenderPictFormat *format; + XRenderPictureAttributes pa; + unsigned long mask = 0; + + format = _XftDrawFormat (draw); + if (!format) + return FcFalse; + + if (draw->subwindow_mode == IncludeInferiors) + { + pa.subwindow_mode = IncludeInferiors; + mask |= CPSubwindowMode; + } + draw->render.pict = XRenderCreatePicture (draw->dpy, draw->drawable, + format, mask, &pa); + if (!draw->render.pict) + return FcFalse; + switch (draw->clip_type) { + case XftClipTypeRegion: + XRenderSetPictureClipRegion (draw->dpy, draw->render.pict, + draw->clip.region); + break; + case XftClipTypeRectangles: + XRenderSetPictureClipRectangles (draw->dpy, draw->render.pict, + draw->clip.rect->xOrigin, + draw->clip.rect->yOrigin, + XftClipRects(draw->clip.rect), + draw->clip.rect->n); + break; + case XftClipTypeNone: + break; + } + } + return FcTrue; +} + +static FcBool +_XftDrawCorePrepare (XftDraw *draw, _Xconst XftColor *color) +{ + if (!draw->core.gc) + { + XGCValues gcv; + unsigned long mask = 0; + if (draw->subwindow_mode == IncludeInferiors) + { + gcv.subwindow_mode = IncludeInferiors; + mask |= GCSubwindowMode; + } + draw->core.gc = XCreateGC (draw->dpy, draw->drawable, mask, &gcv); + if (!draw->core.gc) + return FcFalse; + switch (draw->clip_type) { + case XftClipTypeRegion: + XSetRegion (draw->dpy, draw->core.gc, draw->clip.region); + break; + case XftClipTypeRectangles: + XSetClipRectangles (draw->dpy, draw->core.gc, + draw->clip.rect->xOrigin, + draw->clip.rect->yOrigin, + XftClipRects (draw->clip.rect), + draw->clip.rect->n, + Unsorted); + break; + case XftClipTypeNone: + break; + } + } + XSetForeground (draw->dpy, draw->core.gc, color->pixel); + return FcTrue; +} + +_X_EXPORT Picture +XftDrawPicture (XftDraw *draw) +{ + if (!_XftDrawRenderPrepare (draw)) + return 0; + return draw->render.pict; +} + +#define NUM_LOCAL 1024 + +_X_EXPORT void +XftDrawGlyphs (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + int x, + int y, + _Xconst FT_UInt *glyphs, + int nglyphs) +{ + XftFontInt *font = (XftFontInt *) pub; + + if (font->format) + { + Picture src; + + if (_XftDrawRenderPrepare (draw) && + (src = XftDrawSrcPicture (draw, color))) + XftGlyphRender (draw->dpy, _XftDrawOp (draw, color), + src, pub, draw->render.pict, + 0, 0, x, y, glyphs, nglyphs); + } + else + { + if (_XftDrawCorePrepare (draw, color)) + XftGlyphCore (draw, color, pub, x, y, glyphs, nglyphs); + } +} + +_X_EXPORT void +XftDrawString8 (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + int x, + int y, + _Xconst FcChar8 *string, + int len) +{ + FT_UInt *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (XftDebug () & XFT_DBG_DRAW) + printf ("DrawString \"%*.*s\"\n", len, len, string); + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (FT_UInt)); + if (!glyphs) + return; + } + for (i = 0; i < len; i++) + glyphs[i] = XftCharIndex (draw->dpy, pub, string[i]); + XftDrawGlyphs (draw, color, pub, x, y, glyphs, len); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftDrawString16 (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + int x, + int y, + _Xconst FcChar16 *string, + int len) +{ + FT_UInt *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (FT_UInt)); + if (!glyphs) + return; + } + for (i = 0; i < len; i++) + glyphs[i] = XftCharIndex (draw->dpy, pub, string[i]); + + XftDrawGlyphs (draw, color, pub, x, y, glyphs, len); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftDrawString32 (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + int x, + int y, + _Xconst FcChar32 *string, + int len) +{ + FT_UInt *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (FT_UInt)); + if (!glyphs) + return; + } + for (i = 0; i < len; i++) + glyphs[i] = XftCharIndex (draw->dpy, pub, string[i]); + + XftDrawGlyphs (draw, color, pub, x, y, glyphs, len); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftDrawStringUtf8 (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + int x, + int y, + _Xconst FcChar8 *string, + int len) +{ + FT_UInt *glyphs, *glyphs_new, glyphs_local[NUM_LOCAL]; + FcChar32 ucs4; + int i; + int l; + int size; + + i = 0; + glyphs = glyphs_local; + size = NUM_LOCAL; + while (len && (l = FcUtf8ToUcs4 (string, &ucs4, len)) > 0) + { + if (i == size) + { + glyphs_new = malloc (size * 2 * sizeof (FT_UInt)); + if (!glyphs_new) + { + if (glyphs != glyphs_local) + free (glyphs); + return; + } + memcpy (glyphs_new, glyphs, size * sizeof (FT_UInt)); + size *= 2; + if (glyphs != glyphs_local) + free (glyphs); + glyphs = glyphs_new; + } + glyphs[i++] = XftCharIndex (draw->dpy, pub, ucs4); + string += l; + len -= l; + } + XftDrawGlyphs (draw, color, pub, x, y, glyphs, i); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftDrawStringUtf16 (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + int x, + int y, + _Xconst FcChar8 *string, + FcEndian endian, + int len) +{ + FT_UInt *glyphs, *glyphs_new, glyphs_local[NUM_LOCAL]; + FcChar32 ucs4; + int i; + int l; + int size; + + i = 0; + glyphs = glyphs_local; + size = NUM_LOCAL; + while (len && (l = FcUtf16ToUcs4 (string, endian, &ucs4, len)) > 0) + { + if (i == size) + { + glyphs_new = malloc (size * 2 * sizeof (FT_UInt)); + if (!glyphs_new) + { + if (glyphs != glyphs_local) + free (glyphs); + return; + } + memcpy (glyphs_new, glyphs, size * sizeof (FT_UInt)); + size *= 2; + if (glyphs != glyphs_local) + free (glyphs); + glyphs = glyphs_new; + } + glyphs[i++] = XftCharIndex (draw->dpy, pub, ucs4); + string += l; + len -= l; + } + XftDrawGlyphs (draw, color, pub, x, y, glyphs, i); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftDrawGlyphSpec (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + _Xconst XftGlyphSpec *glyphs, + int len) +{ + XftFontInt *font = (XftFontInt *) pub; + + if (font->format) + { + Picture src; + + if (_XftDrawRenderPrepare (draw) && + (src = XftDrawSrcPicture (draw, color))) + { + XftGlyphSpecRender (draw->dpy, _XftDrawOp (draw, color), + src, pub, draw->render.pict, + 0, 0, glyphs, len); + } + } + else + { + if (_XftDrawCorePrepare (draw, color)) + XftGlyphSpecCore (draw, color, pub, glyphs, len); + } +} + +_X_EXPORT void +XftDrawGlyphFontSpec (XftDraw *draw, + _Xconst XftColor *color, + _Xconst XftGlyphFontSpec *glyphs, + int len) +{ + int i; + int start; + + i = 0; + while (i < len) + { + start = i; + if (((XftFontInt *) glyphs[i].font)->format) + { + Picture src; + while (i < len && ((XftFontInt *) glyphs[i].font)->format) + i++; + if (_XftDrawRenderPrepare (draw) && + (src = XftDrawSrcPicture (draw, color))) + { + XftGlyphFontSpecRender (draw->dpy, _XftDrawOp (draw, color), + src, draw->render.pict, + 0, 0, glyphs + start , i - start); + } + } + else + { + while (i < len && !((XftFontInt *) glyphs[i].font)->format) + i++; + if (_XftDrawCorePrepare (draw, color)) + XftGlyphFontSpecCore (draw, color, glyphs + start, i - start); + } + } +} + +_X_EXPORT void +XftDrawCharSpec (XftDraw *draw, + _Xconst XftColor *color, + XftFont *pub, + _Xconst XftCharSpec *chars, + int len) +{ + XftGlyphSpec *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (XftGlyphSpec)); + if (!glyphs) + return; + } + for (i = 0; i < len; i++) + { + glyphs[i].glyph = XftCharIndex(draw->dpy, pub, chars[i].ucs4); + glyphs[i].x = chars[i].x; + glyphs[i].y = chars[i].y; + } + + XftDrawGlyphSpec (draw, color, pub, glyphs, len); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftDrawCharFontSpec (XftDraw *draw, + _Xconst XftColor *color, + _Xconst XftCharFontSpec *chars, + int len) +{ + XftGlyphFontSpec *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (XftGlyphFontSpec)); + if (!glyphs) + return; + } + for (i = 0; i < len; i++) + { + glyphs[i].font = chars[i].font; + glyphs[i].glyph = XftCharIndex(draw->dpy, glyphs[i].font, chars[i].ucs4); + glyphs[i].x = chars[i].x; + glyphs[i].y = chars[i].y; + } + + XftDrawGlyphFontSpec (draw, color, glyphs, len); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftDrawRect (XftDraw *draw, + _Xconst XftColor *color, + int x, + int y, + unsigned int width, + unsigned int height) +{ + if (_XftDrawRenderPrepare (draw)) + { + XRenderFillRectangle (draw->dpy, PictOpSrc, draw->render.pict, + &color->color, x, y, width, height); + } + else if (_XftDrawCorePrepare (draw, color)) + { + /* note: not XftRectCore() */ + XSetForeground (draw->dpy, draw->core.gc, color->pixel); + XFillRectangle (draw->dpy, draw->drawable, draw->core.gc, + x, y, width, height); + } +} + +_X_EXPORT Bool +XftDrawSetClip (XftDraw *draw, + Region r) +{ + Region n = NULL; + + /* + * Check for quick exits + */ + if (!r && draw->clip_type == XftClipTypeNone) + return True; + + if (r && + draw->clip_type == XftClipTypeRegion && + XEqualRegion (r, draw->clip.region)) + { + return True; + } + + /* + * Duplicate the region so future changes can be short circuited + */ + if (r) + { + n = XCreateRegion (); + if (n) + { + if (!XUnionRegion (n, r, n)) + { + XDestroyRegion (n); + return False; + } + } + } + + /* + * Destroy existing clip + */ + switch (draw->clip_type) { + case XftClipTypeRegion: + XDestroyRegion (draw->clip.region); + break; + case XftClipTypeRectangles: + free (draw->clip.rect); + break; + case XftClipTypeNone: + break; + } + + /* + * Set the clip + */ + if (n) + { + draw->clip_type = XftClipTypeRegion; + draw->clip.region = n; + } + else + { + draw->clip_type = XftClipTypeNone; + } + /* + * Apply new clip to existing objects + */ + if (draw->render.pict) + { + if (n) + XRenderSetPictureClipRegion (draw->dpy, draw->render.pict, n); + else + { + XRenderPictureAttributes pa; + pa.clip_mask = None; + XRenderChangePicture (draw->dpy, draw->render.pict, + CPClipMask, &pa); + } + } + if (draw->core.gc) + { + if (n) + XSetRegion (draw->dpy, draw->core.gc, draw->clip.region); + else + XSetClipMask (draw->dpy, draw->core.gc, None); + } + return True; +} + +_X_EXPORT Bool +XftDrawSetClipRectangles (XftDraw *draw, + int xOrigin, + int yOrigin, + _Xconst XRectangle *rects, + int n) +{ + XftClipRect *new = NULL; + + /* + * Check for quick exit + */ + if (draw->clip_type == XftClipTypeRectangles && + draw->clip.rect->n == n && + (n == 0 || (draw->clip.rect->xOrigin == xOrigin && + draw->clip.rect->yOrigin == yOrigin)) && + !memcmp (XftClipRects (draw->clip.rect), rects, n * sizeof (XRectangle))) + { + return True; + } + + /* + * Duplicate the region so future changes can be short circuited + */ + new = malloc (sizeof (XftClipRect) + n * sizeof (XRectangle)); + if (!new) + return False; + + new->n = n; + new->xOrigin = xOrigin; + new->yOrigin = yOrigin; + memcpy (XftClipRects (new), rects, n * sizeof (XRectangle)); + + /* + * Destroy existing clip + */ + switch (draw->clip_type) { + case XftClipTypeRegion: + XDestroyRegion (draw->clip.region); + break; + case XftClipTypeRectangles: + free (draw->clip.rect); + break; + case XftClipTypeNone: + break; + } + + /* + * Set the clip + */ + draw->clip_type = XftClipTypeRectangles; + draw->clip.rect = new; + /* + * Apply new clip to existing objects + */ + if (draw->render.pict) + { + XRenderSetPictureClipRectangles (draw->dpy, draw->render.pict, + new->xOrigin, + new->yOrigin, + XftClipRects(new), + new->n); + } + if (draw->core.gc) + { + XSetClipRectangles (draw->dpy, draw->core.gc, + new->xOrigin, + new->yOrigin, + XftClipRects (new), + new->n, + Unsorted); + } + return True; +} + +_X_EXPORT void +XftDrawSetSubwindowMode (XftDraw *draw, int mode) +{ + if (mode == draw->subwindow_mode) + return; + draw->subwindow_mode = mode; + if (draw->render.pict) + { + XRenderPictureAttributes pa; + + pa.subwindow_mode = mode; + XRenderChangePicture (draw->dpy, draw->render.pict, + CPSubwindowMode, &pa); + } + if (draw->core.gc) + XSetSubwindowMode (draw->dpy, draw->core.gc, mode); +} diff --git a/libXft/src/xftextent.c b/libXft/src/xftextent.c new file mode 100644 index 000000000..71f5c1c13 --- /dev/null +++ b/libXft/src/xftextent.c @@ -0,0 +1,285 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +_X_EXPORT void +XftGlyphExtents (Display *dpy, + XftFont *pub, + _Xconst FT_UInt *glyphs, + int nglyphs, + XGlyphInfo *extents) +{ + XftFontInt *font = (XftFontInt *) pub; + FT_UInt missing[XFT_NMISSING]; + int nmissing; + int n; + _Xconst FT_UInt *g; + FT_UInt glyph; + XftGlyph *xftg; + FcBool glyphs_loaded; + int x, y; + int left, right, top, bottom; + int overall_left, overall_right; + int overall_top, overall_bottom; + + g = glyphs; + n = nglyphs; + nmissing = 0; + glyphs_loaded = FcFalse; + while (n--) + if (XftFontCheckGlyph (dpy, pub, FcFalse, *g++, missing, &nmissing)) + glyphs_loaded = FcTrue; + if (nmissing) + XftFontLoadGlyphs (dpy, pub, FcFalse, missing, nmissing); + g = glyphs; + n = nglyphs; + xftg = NULL; + while (n) + { + glyph = *g++; + n--; + if (glyph < font->num_glyphs && + (xftg = font->glyphs[glyph])) + break; + } + if (n == 0) + { + if (xftg) + *extents = xftg->metrics; + else + memset (extents, '\0', sizeof (*extents)); + } + else + { + x = 0; + y = 0; + overall_left = x - xftg->metrics.x; + overall_top = y - xftg->metrics.y; + overall_right = overall_left + (int) xftg->metrics.width; + overall_bottom = overall_top + (int) xftg->metrics.height; + x += xftg->metrics.xOff; + y += xftg->metrics.yOff; + while (n--) + { + glyph = *g++; + if (glyph < font->num_glyphs && (xftg = font->glyphs[glyph])) + { + left = x - xftg->metrics.x; + top = y - xftg->metrics.y; + right = left + (int) xftg->metrics.width; + bottom = top + (int) xftg->metrics.height; + if (left < overall_left) + overall_left = left; + if (top < overall_top) + overall_top = top; + if (right > overall_right) + overall_right = right; + if (bottom > overall_bottom) + overall_bottom = bottom; + x += xftg->metrics.xOff; + y += xftg->metrics.yOff; + } + } + extents->x = -overall_left; + extents->y = -overall_top; + extents->width = overall_right - overall_left; + extents->height = overall_bottom - overall_top; + extents->xOff = x; + extents->yOff = y; + } + if (glyphs_loaded) + _XftFontManageMemory (dpy, pub); +} + +#define NUM_LOCAL 1024 + +_X_EXPORT void +XftTextExtents8 (Display *dpy, + XftFont *pub, + _Xconst FcChar8 *string, + int len, + XGlyphInfo *extents) +{ + FT_UInt *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (FT_UInt)); + if (!glyphs) + { + memset (extents, '\0', sizeof (XGlyphInfo)); + return; + } + } + for (i = 0; i < len; i++) + glyphs[i] = XftCharIndex (dpy, pub, string[i]); + XftGlyphExtents (dpy, pub, glyphs, len, extents); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftTextExtents16 (Display *dpy, + XftFont *pub, + _Xconst FcChar16 *string, + int len, + XGlyphInfo *extents) +{ + FT_UInt *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (FT_UInt)); + if (!glyphs) + { + memset (extents, '\0', sizeof (XGlyphInfo)); + return; + } + } + for (i = 0; i < len; i++) + glyphs[i] = XftCharIndex (dpy, pub, string[i]); + XftGlyphExtents (dpy, pub, glyphs, len, extents); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftTextExtents32 (Display *dpy, + XftFont *pub, + _Xconst FcChar32 *string, + int len, + XGlyphInfo *extents) +{ + FT_UInt *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (FT_UInt)); + if (!glyphs) + { + memset (extents, '\0', sizeof (XGlyphInfo)); + return; + } + } + for (i = 0; i < len; i++) + glyphs[i] = XftCharIndex (dpy, pub, string[i]); + XftGlyphExtents (dpy, pub, glyphs, len, extents); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftTextExtentsUtf8 (Display *dpy, + XftFont *pub, + _Xconst FcChar8 *string, + int len, + XGlyphInfo *extents) +{ + FT_UInt *glyphs, *glyphs_new, glyphs_local[NUM_LOCAL]; + FcChar32 ucs4; + int i; + int l; + int size; + + i = 0; + glyphs = glyphs_local; + size = NUM_LOCAL; + while (len && (l = FcUtf8ToUcs4 (string, &ucs4, len)) > 0) + { + if (i == size) + { + glyphs_new = malloc (size * 2 * sizeof (FT_UInt)); + if (!glyphs_new) + { + if (glyphs != glyphs_local) + free (glyphs); + memset (extents, '\0', sizeof (XGlyphInfo)); + return; + } + memcpy (glyphs_new, glyphs, size * sizeof (FT_UInt)); + size *= 2; + if (glyphs != glyphs_local) + free (glyphs); + glyphs = glyphs_new; + } + glyphs[i++] = XftCharIndex (dpy, pub, ucs4); + string += l; + len -= l; + } + XftGlyphExtents (dpy, pub, glyphs, i, extents); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftTextExtentsUtf16 (Display *dpy, + XftFont *pub, + _Xconst FcChar8 *string, + FcEndian endian, + int len, + XGlyphInfo *extents) +{ + FT_UInt *glyphs, *glyphs_new, glyphs_local[NUM_LOCAL]; + FcChar32 ucs4; + int i; + int l; + int size; + + i = 0; + glyphs = glyphs_local; + size = NUM_LOCAL; + while (len && (l = FcUtf16ToUcs4 (string, endian, &ucs4, len)) > 0) + { + if (i == size) + { + glyphs_new = malloc (size * 2 * sizeof (FT_UInt)); + if (!glyphs_new) + { + if (glyphs != glyphs_local) + free (glyphs); + memset (extents, '\0', sizeof (XGlyphInfo)); + return; + } + memcpy (glyphs_new, glyphs, size * sizeof (FT_UInt)); + size *= 2; + if (glyphs != glyphs_local) + free (glyphs); + glyphs = glyphs_new; + } + glyphs[i++] = XftCharIndex (dpy, pub, ucs4); + string += l; + len -= l; + } + XftGlyphExtents (dpy, pub, glyphs, i, extents); + if (glyphs != glyphs_local) + free (glyphs); +} diff --git a/libXft/src/xftfont.c b/libXft/src/xftfont.c new file mode 100644 index 000000000..70ab5d8bb --- /dev/null +++ b/libXft/src/xftfont.c @@ -0,0 +1,206 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +_X_EXPORT FcPattern * +XftFontMatch (Display *dpy, + int screen, + _Xconst FcPattern *pattern, + FcResult *result) +{ + FcPattern *new; + FcPattern *match; + + if (!XftInit (NULL)) + return NULL; + + new = FcPatternDuplicate (pattern); + if (!new) + return NULL; + + if (XftDebug () & XFT_DBG_OPENV) + { + printf ("XftFontMatch pattern "); + FcPatternPrint (new); + } + FcConfigSubstitute (NULL, new, FcMatchPattern); + if (XftDebug () & XFT_DBG_OPENV) + { + printf ("XftFontMatch after FcConfig substitutions "); + FcPatternPrint (new); + } + XftDefaultSubstitute (dpy, screen, new); + if (XftDebug () & XFT_DBG_OPENV) + { + printf ("XftFontMatch after X resource substitutions "); + FcPatternPrint (new); + } + + match = FcFontMatch (NULL, new, result); + if (XftDebug () & XFT_DBG_OPENV) + { + printf ("XftFontMatch result "); + FcPatternPrint (match); + } + FcPatternDestroy (new); + return match; +} + +_X_EXPORT XftFont * +XftFontOpen (Display *dpy, int screen, ...) +{ + va_list va; + FcPattern *pat; + FcPattern *match; + FcResult result; + XftFont *font; + + va_start (va, screen); + pat = FcPatternVaBuild (NULL, va); + va_end (va); + if (!pat) + { + if (XftDebug () & XFT_DBG_OPEN) + printf ("XftFontOpen: Invalid pattern argument\n"); + return NULL; + } + match = XftFontMatch (dpy, screen, pat, &result); + if (XftDebug () & XFT_DBG_OPEN) + { + printf ("Pattern "); + FcPatternPrint (pat); + if (match) + { + printf ("Match "); + FcPatternPrint (match); + } + else + printf ("No Match\n"); + } + FcPatternDestroy (pat); + if (!match) + return NULL; + + font = XftFontOpenPattern (dpy, match); + if (!font) + { + if (XftDebug () & XFT_DBG_OPEN) + printf ("No Font\n"); + FcPatternDestroy (match); + } + + return font; +} + +_X_EXPORT XftFont * +XftFontOpenName (Display *dpy, int screen, const char *name) +{ + FcPattern *pat; + FcPattern *match; + FcResult result; + XftFont *font; + + pat = FcNameParse ((FcChar8 *) name); + if (XftDebug () & XFT_DBG_OPEN) + { + printf ("XftFontOpenName \"%s\": ", name); + if (pat) + FcPatternPrint (pat); + else + printf ("Invalid name\n"); + } + + if (!pat) + return NULL; + match = XftFontMatch (dpy, screen, pat, &result); + if (XftDebug () & XFT_DBG_OPEN) + { + if (match) + { + printf ("Match "); + FcPatternPrint (match); + } + else + printf ("No Match\n"); + } + FcPatternDestroy (pat); + if (!match) + return NULL; + + font = XftFontOpenPattern (dpy, match); + if (!font) + { + if (XftDebug () & XFT_DBG_OPEN) + printf ("No Font\n"); + FcPatternDestroy (match); + } + + return font; +} + +_X_EXPORT XftFont * +XftFontOpenXlfd (Display *dpy, int screen, const char *xlfd) +{ + FcPattern *pat; + FcPattern *match; + FcResult result; + XftFont *font; + + pat = XftXlfdParse (xlfd, FcFalse, FcFalse); + if (XftDebug () & XFT_DBG_OPEN) + { + printf ("XftFontOpenXlfd \"%s\": ", xlfd); + if (pat) + printf ("Invalid xlfd\n"); + else + FcPatternPrint (pat); + } + + if (!pat) + return NULL; + match = XftFontMatch (dpy, screen, pat, &result); + if (XftDebug () & XFT_DBG_OPEN) + { + if (match) + { + printf ("Match "); + FcPatternPrint (match); + } + else + printf ("No Match\n"); + } + FcPatternDestroy (pat); + if (!match) + return NULL; + + font = XftFontOpenPattern (dpy, match); + if (!font) + { + if (XftDebug () & XFT_DBG_OPEN) + printf ("No Font\n"); + FcPatternDestroy (match); + } + + return font; +} + diff --git a/libXft/src/xftfreetype.c b/libXft/src/xftfreetype.c new file mode 100644 index 000000000..7238b8259 --- /dev/null +++ b/libXft/src/xftfreetype.c @@ -0,0 +1,1174 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +_X_HIDDEN FT_Library _XftFTlibrary; + +#define FT_Matrix_Equal(a,b) ((a)->xx == (b)->xx && \ + (a)->yy == (b)->yy && \ + (a)->xy == (b)->xy && \ + (a)->yx == (b)->yx) +/* + * List of all open files (each face in a file is managed separately) + */ + +static XftFtFile *_XftFtFiles; +static int XftMaxFreeTypeFiles = 5; + +static XftFtFile * +_XftGetFile (const FcChar8 *file, int id) +{ + XftFtFile *f; + + if (!XftInitFtLibrary ()) + return NULL; + + for (f = _XftFtFiles; f; f = f->next) + { + if (!strcmp (f->file, (char *) file) && f->id == id) + { + ++f->ref; + if (XftDebug () & XFT_DBG_REF) + printf ("FontFile %s/%d matches existing (%d)\n", + file, id, f->ref); + return f; + } + } + f = malloc (sizeof (XftFtFile) + strlen ((char *) file) + 1); + if (!f) + return NULL; + + XftMemAlloc (XFT_MEM_FILE, sizeof (XftFtFile) + strlen ((char *) file) + 1); + if (XftDebug () & XFT_DBG_REF) + printf ("FontFile %s/%d matches new\n", + file, id); + f->next = _XftFtFiles; + _XftFtFiles = f; + + f->ref = 1; + + f->file = (char *) (f+1); + strcpy (f->file, (char *) file); + f->id = id; + + f->lock = 0; + f->face = NULL; + f->xsize = 0; + f->ysize = 0; + f->matrix.xx = f->matrix.xy = f->matrix.yx = f->matrix.yy = 0; + return f; +} + +static XftFtFile * +_XftGetFaceFile (FT_Face face) +{ + XftFtFile *f; + + f = malloc (sizeof (XftFtFile)); + if (!f) + return NULL; + XftMemAlloc (XFT_MEM_FILE, sizeof(XftFtFile)); + f->next = NULL; + + f->ref = 1; + + f->file = NULL; + f->id = 0; + f->lock = 0; + f->face = face; + f->xsize = 0; + f->ysize = 0; + f->matrix.xx = f->matrix.xy = f->matrix.yx = f->matrix.yy = 0; + return f; +} + +static int +_XftNumFiles (void) +{ + XftFtFile *f; + int count = 0; + for (f = _XftFtFiles; f; f = f->next) + if (f->face && !f->lock) + ++count; + return count; +} + +static XftFtFile * +_XftNthFile (int n) +{ + XftFtFile *f; + int count = 0; + for (f = _XftFtFiles; f; f = f->next) + if (f->face && !f->lock) + if (count++ == n) + break; + return f; +} + +static void +_XftUncacheFiles (void) +{ + int n; + XftFtFile *f; + while ((n = _XftNumFiles ()) > XftMaxFreeTypeFiles) + { + f = _XftNthFile (rand () % n); + if (f) + { + if (XftDebug() & XFT_DBG_REF) + printf ("Discard file %s/%d from cache\n", + f->file, f->id); + FT_Done_Face (f->face); + f->face = NULL; + } + } +} + +static FT_Face +_XftLockFile (XftFtFile *f) +{ + ++f->lock; + if (!f->face) + { + if (XftDebug() & XFT_DBG_REF) + printf ("Loading file %s/%d\n", f->file, f->id); + if (FT_New_Face (_XftFTlibrary, f->file, f->id, &f->face)) + --f->lock; + + f->xsize = 0; + f->ysize = 0; + f->matrix.xx = f->matrix.xy = f->matrix.yx = f->matrix.yy = 0; + _XftUncacheFiles (); + } + return f->face; +} + +static void +_XftLockError (char *reason) +{ + fprintf (stderr, "Xft: locking error %s\n", reason); +} + +static void +_XftUnlockFile (XftFtFile *f) +{ + if (--f->lock < 0) + _XftLockError ("too many file unlocks"); +} + +#if HAVE_FT_BITMAP_SIZE_Y_PPEM +#define X_SIZE(face,i) ((face)->available_sizes[i].x_ppem) +#define Y_SIZE(face,i) ((face)->available_sizes[i].y_ppem) +#else +#define X_SIZE(face,i) ((face)->available_sizes[i].width << 6) +#define Y_SIZE(face,i) ((face)->available_sizes[i].height << 6) +#endif + +_X_HIDDEN FcBool +_XftSetFace (XftFtFile *f, FT_F26Dot6 xsize, FT_F26Dot6 ysize, FT_Matrix *matrix) +{ + FT_Face face = f->face; + + if (f->xsize != xsize || f->ysize != ysize) + { + if (XftDebug() & XFT_DBG_GLYPH) + printf ("Set face size to %dx%d (%dx%d)\n", + (int) (xsize >> 6), (int) (ysize >> 6), (int) xsize, (int) ysize); + /* + * Bitmap only faces must match exactly, so find the closest + * one (height dominant search) + */ + if (!(face->face_flags & FT_FACE_FLAG_SCALABLE)) + { + int i, best = 0; + +#define xft_abs(a) ((a) < 0 ? -(a) : (a)) +#define dist(a,b) (xft_abs((a)-(b))) + + for (i = 1; i < face->num_fixed_sizes; i++) + { + if (dist (ysize, Y_SIZE(face,i)) < + dist (ysize, Y_SIZE(face, best)) || + (dist (ysize, Y_SIZE(face, i)) == + dist (ysize, Y_SIZE(face, best)) && + dist (xsize, X_SIZE(face, i)) < + dist (xsize, X_SIZE(face, best)))) + { + best = i; + } + } + /* + * Freetype 2.1.7 and earlier used width/height + * for matching sizes in the BDF and PCF loaders. + * This has been fixed for 2.1.8. Because BDF and PCF + * files have but a single strike per file, we can + * simply try both sizes. + */ + if ( +#if HAVE_FT_BITMAP_SIZE_Y_PPEM + FT_Set_Char_Size (face, face->available_sizes[best].x_ppem, + face->available_sizes[best].y_ppem, 0, 0) != 0 + && +#endif + FT_Set_Char_Size (face, face->available_sizes[best].width << 6, + face->available_sizes[best].height << 6, + 0, 0) != 0) + { + return False; + } + } + else + { + if (FT_Set_Char_Size (face, xsize, ysize, 0, 0)) + { + return False; + } + } + f->xsize = xsize; + f->ysize = ysize; + } + if (!FT_Matrix_Equal (&f->matrix, matrix)) + { + if (XftDebug() & XFT_DBG_GLYPH) + printf ("Set face matrix to (%g,%g,%g,%g)\n", + (double) matrix->xx / 0x10000, + (double) matrix->xy / 0x10000, + (double) matrix->yx / 0x10000, + (double) matrix->yy / 0x10000); + FT_Set_Transform (face, matrix, NULL); + f->matrix = *matrix; + } + return True; +} + +static void +_XftReleaseFile (XftFtFile *f) +{ + XftFtFile **prev; + + if (--f->ref != 0) + return; + if (f->lock) + _XftLockError ("Attempt to close locked file"); + if (f->file) + { + for (prev = &_XftFtFiles; *prev; prev = &(*prev)->next) + { + if (*prev == f) + { + *prev = f->next; + break; + } + } + if (f->face) + FT_Done_Face (f->face); + } + XftMemFree (XFT_MEM_FILE, + sizeof (XftFtFile) + (f->file ? strlen (f->file) + 1 : 0)); + free (f); +} + +/* + * Find a prime larger than the minimum reasonable hash size + */ + +static FcChar32 +_XftSqrt (FcChar32 a) +{ + FcChar32 l, h, m; + + l = 2; + h = a/2; + while ((h-l) > 1) + { + m = (h+l) >> 1; + if (m * m < a) + l = m; + else + h = m; + } + return h; +} + +static FcBool +_XftIsPrime (FcChar32 i) +{ + FcChar32 l, t; + + if (i < 2) + return FcFalse; + if ((i & 1) == 0) + { + if (i == 2) + return FcTrue; + return FcFalse; + } + l = _XftSqrt (i) + 1; + for (t = 3; t <= l; t += 2) + if (i % t == 0) + return FcFalse; + return FcTrue; +} + +static FcChar32 +_XftHashSize (FcChar32 num_unicode) +{ + /* at least 31.25 % extra space */ + FcChar32 hash = num_unicode + (num_unicode >> 2) + (num_unicode >> 4); + + if ((hash & 1) == 0) + hash++; + while (!_XftIsPrime (hash)) + hash += 2; + return hash; +} + +_X_EXPORT FT_Face +XftLockFace (XftFont *public) +{ + XftFontInt *font = (XftFontInt *) public; + XftFontInfo *fi = &font->info; + FT_Face face; + + face = _XftLockFile (fi->file); + /* + * Make sure the face is usable at the requested size + */ + if (face && !_XftSetFace (fi->file, fi->xsize, fi->ysize, &fi->matrix)) + { + _XftUnlockFile (fi->file); + face = NULL; + } + return face; +} + +_X_EXPORT void +XftUnlockFace (XftFont *public) +{ + XftFontInt *font = (XftFontInt *) public; + _XftUnlockFile (font->info.file); +} + +static FcBool +XftFontInfoFill (Display *dpy, _Xconst FcPattern *pattern, XftFontInfo *fi) +{ + XftDisplayInfo *info = _XftDisplayInfoGet (dpy, True); + FcChar8 *filename; + int id; + double dsize; + double aspect; + FcMatrix *font_matrix; + FcBool hinting, vertical_layout, autohint, global_advance; +#ifdef FC_HINT_STYLE + int hint_style; +#endif + FcChar32 hash, *hashp; + FT_Face face; + int nhash; + FcBool bitmap; + + if (!info) + return FcFalse; + + /* + * Initialize the whole XftFontInfo so that padding doesn't interfere with + * hash or XftFontInfoEqual(). + */ + + memset (fi, '\0', sizeof(*fi)); + + /* + * Find the associated file + */ + switch (FcPatternGetString (pattern, FC_FILE, 0, &filename)) { + case FcResultNoMatch: + filename = NULL; + break; + case FcResultMatch: + break; + default: + goto bail0; + } + + switch (FcPatternGetInteger (pattern, FC_INDEX, 0, &id)) { + case FcResultNoMatch: + id = 0; + break; + case FcResultMatch: + break; + default: + goto bail0; + } + + if (filename) + fi->file = _XftGetFile (filename, id); + else if (FcPatternGetFTFace (pattern, FC_FT_FACE, 0, &face) == FcResultMatch + && face) + fi->file = _XftGetFaceFile (face); + if (!fi->file) + goto bail0; + + /* + * Compute pixel size + */ + if (FcPatternGetDouble (pattern, FC_PIXEL_SIZE, 0, &dsize) != FcResultMatch) + goto bail1; + + if (FcPatternGetDouble (pattern, FC_ASPECT, 0, &aspect) != FcResultMatch) + aspect = 1.0; + + fi->ysize = (FT_F26Dot6) (dsize * 64.0); + fi->xsize = (FT_F26Dot6) (dsize * aspect * 64.0); + + if (XftDebug() & XFT_DBG_OPEN) + printf ("XftFontInfoFill: %s: %d (%g pixels)\n", + (filename ? filename : (FcChar8 *) "<none>"), id, dsize); + /* + * Get antialias value + */ + switch (FcPatternGetBool (pattern, FC_ANTIALIAS, 0, &fi->antialias)) { + case FcResultNoMatch: + fi->antialias = True; + break; + case FcResultMatch: + break; + default: + goto bail1; + } + + /* + * Get rgba value + */ + switch (FcPatternGetInteger (pattern, FC_RGBA, 0, &fi->rgba)) { + case FcResultNoMatch: + fi->rgba = FC_RGBA_UNKNOWN; + break; + case FcResultMatch: + break; + default: + goto bail1; + } + + /* + * Get matrix and transform values + */ + switch (FcPatternGetMatrix (pattern, FC_MATRIX, 0, &font_matrix)) { + case FcResultNoMatch: + fi->matrix.xx = fi->matrix.yy = 0x10000; + fi->matrix.xy = fi->matrix.yx = 0; + break; + case FcResultMatch: + fi->matrix.xx = 0x10000L * font_matrix->xx; + fi->matrix.yy = 0x10000L * font_matrix->yy; + fi->matrix.xy = 0x10000L * font_matrix->xy; + fi->matrix.yx = 0x10000L * font_matrix->yx; + break; + default: + goto bail1; + } + + fi->transform = (fi->matrix.xx != 0x10000 || fi->matrix.xy != 0 || + fi->matrix.yx != 0 || fi->matrix.yy != 0x10000); + + /* + * Get render value, set to false if no Render extension present + */ + if (info->hasRender) + { + switch (FcPatternGetBool (pattern, XFT_RENDER, 0, &fi->render)) { + case FcResultNoMatch: + fi->render = info->hasRender; + break; + case FcResultMatch: + break; + default: + goto bail1; + } + } + else + fi->render = FcFalse; + + /* + * Compute glyph load flags + */ + fi->load_flags = FT_LOAD_DEFAULT; + +#ifndef XFT_EMBEDDED_BITMAP +#define XFT_EMBEDDED_BITMAP "embeddedbitmap" +#endif + + switch (FcPatternGetBool (pattern, XFT_EMBEDDED_BITMAP, 0, &bitmap)) { + case FcResultNoMatch: + bitmap = FcFalse; + break; + case FcResultMatch: + break; + default: + goto bail1; + } + + /* disable bitmaps when anti-aliasing or transforming glyphs */ + if ((!bitmap && fi->antialias) || fi->transform) + fi->load_flags |= FT_LOAD_NO_BITMAP; + + /* disable hinting if requested */ + switch (FcPatternGetBool (pattern, FC_HINTING, 0, &hinting)) { + case FcResultNoMatch: + hinting = FcTrue; + break; + case FcResultMatch: + break; + default: + goto bail1; + } + +#ifdef FC_EMBOLDEN + switch (FcPatternGetBool (pattern, FC_EMBOLDEN, 0, &fi->embolden)) { + case FcResultNoMatch: + fi->embolden = FcFalse; + break; + case FcResultMatch: + break; + default: + goto bail1; + } +#else + fi->embolden = FcFalse; +#endif + +#ifdef FC_HINT_STYLE + switch (FcPatternGetInteger (pattern, FC_HINT_STYLE, 0, &hint_style)) { + case FcResultNoMatch: + hint_style = FC_HINT_FULL; + break; + case FcResultMatch: + break; + default: + goto bail1; + } +#endif + + if (!hinting +#ifdef FC_HINT_STYLE + || hint_style == FC_HINT_NONE +#endif + ) + { + fi->load_flags |= FT_LOAD_NO_HINTING; + } + + /* Figure out the load target, which modifies the hinting + * behavior of FreeType based on the intended use of the glyphs. + */ + if (fi->antialias) + { +#ifdef FC_HINT_STYLE +#ifdef FT_LOAD_TARGET_LIGHT + if (FC_HINT_NONE < hint_style && hint_style < FC_HINT_FULL) + { + fi->load_flags |= FT_LOAD_TARGET_LIGHT; + } + else +#endif +#endif + { + /* autohinter will snap stems to integer widths, when + * the LCD targets are used. + */ + switch (fi->rgba) { + case FC_RGBA_RGB: + case FC_RGBA_BGR: +#ifdef FT_LOAD_TARGET_LCD + fi->load_flags |= FT_LOAD_TARGET_LCD; +#endif + break; + case FC_RGBA_VRGB: + case FC_RGBA_VBGR: +#ifdef FT_LOAD_TARGET_LCD_V + fi->load_flags |= FT_LOAD_TARGET_LCD_V; +#endif + break; + } + } + } +#ifdef FT_LOAD_TARGET_MONO + else + fi->load_flags |= FT_LOAD_TARGET_MONO; +#endif + + /* set vertical layout if requested */ + switch (FcPatternGetBool (pattern, FC_VERTICAL_LAYOUT, 0, &vertical_layout)) { + case FcResultNoMatch: + vertical_layout = FcFalse; + break; + case FcResultMatch: + break; + default: + goto bail1; + } + + if (vertical_layout) + fi->load_flags |= FT_LOAD_VERTICAL_LAYOUT; + + /* force autohinting if requested */ + switch (FcPatternGetBool (pattern, FC_AUTOHINT, 0, &autohint)) { + case FcResultNoMatch: + autohint = FcFalse; + break; + case FcResultMatch: + break; + default: + goto bail1; + } + + if (autohint) + fi->load_flags |= FT_LOAD_FORCE_AUTOHINT; + + /* disable global advance width (for broken DynaLab TT CJK fonts) */ + switch (FcPatternGetBool (pattern, FC_GLOBAL_ADVANCE, 0, &global_advance)) { + case FcResultNoMatch: + global_advance = FcTrue; + break; + case FcResultMatch: + break; + default: + goto bail1; + } + + if (!global_advance) + fi->load_flags |= FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH; + + /* + * Get requested spacing value + */ + switch (FcPatternGetInteger (pattern, FC_SPACING, 0, &fi->spacing)) { + case FcResultNoMatch: + fi->spacing = FC_PROPORTIONAL; + break; + case FcResultMatch: + break; + default: + goto bail1; + } + + /* + * Check for minspace + */ + + switch (FcPatternGetBool (pattern, FC_MINSPACE, 0, &fi->minspace)) { + case FcResultNoMatch: + fi->minspace = FcFalse; + break; + case FcResultMatch: + break; + default: + goto bail1; + } + /* + * Check for fixed pixel spacing + */ + switch (FcPatternGetInteger (pattern, FC_CHAR_WIDTH, 0, &fi->char_width)) { + case FcResultNoMatch: + fi->char_width = 0; + break; + case FcResultMatch: + if (fi->char_width) + fi->spacing = FC_MONO; + break; + default: + goto bail1; + } + + /* + * Step over hash value in the structure + */ + hash = 0; + hashp = (FcChar32 *) fi + 1; + nhash = (sizeof (XftFontInfo) / sizeof (FcChar32)) - 1; + + while (nhash--) + hash += *hashp++; + fi->hash = hash; + + /* + * All done + */ + return FcTrue; + +bail1: + _XftReleaseFile (fi->file); + fi->file = NULL; +bail0: + return FcFalse; +} + +static void +XftFontInfoEmpty (Display *dpy, XftFontInfo *fi) +{ + if (fi->file) + _XftReleaseFile (fi->file); +} + +XftFontInfo * +XftFontInfoCreate (Display *dpy, _Xconst FcPattern *pattern) +{ + XftFontInfo *fi = malloc (sizeof (XftFontInfo)); + + if (!fi) + return NULL; + + if (!XftFontInfoFill (dpy, pattern, fi)) + { + free (fi); + fi = NULL; + } + XftMemAlloc (XFT_MEM_FONT, sizeof (XftFontInfo)); + return fi; +} + +_X_EXPORT void +XftFontInfoDestroy (Display *dpy, XftFontInfo *fi) +{ + XftFontInfoEmpty (dpy, fi); + XftMemFree (XFT_MEM_FONT, sizeof (XftFontInfo)); + free (fi); +} + +_X_EXPORT FcChar32 +XftFontInfoHash (_Xconst XftFontInfo *fi) +{ + return fi->hash; +} + +_X_EXPORT FcBool +XftFontInfoEqual (_Xconst XftFontInfo *a, _Xconst XftFontInfo *b) +{ + return memcmp ((void *) a, (void *) b, sizeof (XftFontInfo)) == 0; +} + +_X_EXPORT XftFont * +XftFontOpenInfo (Display *dpy, + FcPattern *pattern, + XftFontInfo *fi) +{ + XftDisplayInfo *info = _XftDisplayInfoGet (dpy, True); + FT_Face face; + XftFont **bucket; + XftFontInt *font; + XRenderPictFormat *format; + FcCharSet *charset; + FcChar32 num_unicode; + FcChar32 hash_value; + FcChar32 rehash_value; + FcBool antialias; + int max_glyph_memory; + int alloc_size; + int ascent, descent, height; + int i; + int num_glyphs; + + if (!info) + return NULL; + /* + * Find a matching previously opened font + */ + bucket = &info->fontHash[fi->hash % XFT_NUM_FONT_HASH]; + for (font = (XftFontInt *) *bucket; font; font = (XftFontInt *) font->hash_next) + if (XftFontInfoEqual (&font->info, fi)) + { + if (!font->ref++) + --info->num_unref_fonts; + FcPatternDestroy (pattern); + return &font->public; + } + + /* + * No existing font, create another. + */ + + if (XftDebug () & XFT_DBG_CACHE) + printf ("New font %s/%d size %dx%d\n", + fi->file->file, fi->file->id, + (int) fi->xsize >> 6, (int) fi->ysize >> 6); + + if (FcPatternGetInteger (pattern, XFT_MAX_GLYPH_MEMORY, 0, + &max_glyph_memory) != FcResultMatch) + max_glyph_memory = XFT_FONT_MAX_GLYPH_MEMORY; + + face = _XftLockFile (fi->file); + if (!face) + goto bail0; + + if (!_XftSetFace (fi->file, fi->xsize, fi->ysize, &fi->matrix)) + goto bail1; + + /* + * Get the set of Unicode codepoints covered by the font. + * If the incoming pattern doesn't provide this data, go + * off and compute it. Yes, this is expensive, but it's + * required to map Unicode to glyph indices. + */ + if (FcPatternGetCharSet (pattern, FC_CHARSET, 0, &charset) == FcResultMatch) + charset = FcCharSetCopy (charset); + else + charset = FcFreeTypeCharSet (face, FcConfigGetBlanks (NULL)); + + antialias = fi->antialias; + if (!(face->face_flags & FT_FACE_FLAG_SCALABLE)) + antialias = FcFalse; + + /* + * Find the appropriate picture format + */ + if (fi->render) + { + if (antialias) + { + switch (fi->rgba) { + case FC_RGBA_RGB: + case FC_RGBA_BGR: + case FC_RGBA_VRGB: + case FC_RGBA_VBGR: + format = XRenderFindStandardFormat (dpy, PictStandardARGB32); + break; + default: + format = XRenderFindStandardFormat (dpy, PictStandardA8); + break; + } + } + else + { + format = XRenderFindStandardFormat (dpy, PictStandardA1); + } + + if (!format) + goto bail2; + } + else + format = NULL; + + if (charset) + { + num_unicode = FcCharSetCount (charset); + hash_value = _XftHashSize (num_unicode); + rehash_value = hash_value - 2; + } + else + { + num_unicode = 0; + hash_value = 0; + rehash_value = 0; + } + + /* + * Sometimes the glyphs are numbered 1..n, other times 0..n-1, + * accept either numbering scheme by making room in the table + */ + num_glyphs = face->num_glyphs + 1; + alloc_size = (sizeof (XftFontInt) + + num_glyphs * sizeof (XftGlyph *) + + hash_value * sizeof (XftUcsHash)); + font = malloc (alloc_size); + + if (!font) + goto bail2; + + XftMemAlloc (XFT_MEM_FONT, alloc_size); + + /* + * Public fields + */ + if (fi->transform) + { + FT_Vector vector; + + vector.x = 0; + vector.y = face->size->metrics.descender; + FT_Vector_Transform (&vector, &fi->matrix); + descent = -(vector.y >> 6); + + vector.x = 0; + vector.y = face->size->metrics.ascender; + FT_Vector_Transform (&vector, &fi->matrix); + ascent = vector.y >> 6; + + if (fi->minspace) + height = ascent + descent; + else + { + vector.x = 0; + vector.y = face->size->metrics.height; + FT_Vector_Transform (&vector, &fi->matrix); + height = vector.y >> 6; + } + } + else + { + descent = -(face->size->metrics.descender >> 6); + ascent = face->size->metrics.ascender >> 6; + if (fi->minspace) + height = ascent + descent; + else + height = face->size->metrics.height >> 6; + } + font->public.ascent = ascent; + font->public.descent = descent; + font->public.height = height; + + if (fi->char_width) + font->public.max_advance_width = fi->char_width; + else + { + if (fi->transform) + { + FT_Vector vector; + vector.x = face->size->metrics.max_advance; + vector.y = 0; + FT_Vector_Transform (&vector, &fi->matrix); + font->public.max_advance_width = vector.x >> 6; + } + else + font->public.max_advance_width = face->size->metrics.max_advance >> 6; + } + font->public.charset = charset; + font->public.pattern = pattern; + + /* + * Management fields + */ + font->ref = 1; + + font->next = info->fonts; + info->fonts = &font->public; + + font->hash_next = *bucket; + *bucket = &font->public; + + /* + * Copy the info over + */ + font->info = *fi; + /* + * reset the antialias field. It can't + * be set correctly until the font is opened, + * which doesn't happen in XftFontInfoFill + */ + font->info.antialias = antialias; + /* + * bump XftFile reference count + */ + font->info.file->ref++; + + /* + * Per glyph information + */ + font->glyphs = (XftGlyph **) (font + 1); + memset (font->glyphs, '\0', num_glyphs * sizeof (XftGlyph *)); + font->num_glyphs = num_glyphs; + /* + * Unicode hash table information + */ + font->hash_table = (XftUcsHash *) (font->glyphs + font->num_glyphs); + for (i = 0; i < hash_value; i++) + { + font->hash_table[i].ucs4 = ((FcChar32) ~0); + font->hash_table[i].glyph = 0; + } + font->hash_value = hash_value; + font->rehash_value = rehash_value; + /* + * X specific fields + */ + font->glyphset = 0; + font->format = format; + + /* + * Glyph memory management fields + */ + font->glyph_memory = 0; + font->max_glyph_memory = max_glyph_memory; + font->use_free_glyphs = info->use_free_glyphs; + + _XftUnlockFile (fi->file); + + return &font->public; + +bail2: + FcCharSetDestroy (charset); +bail1: + _XftUnlockFile (fi->file); +bail0: + return NULL; +} + +_X_EXPORT XftFont * +XftFontOpenPattern (Display *dpy, FcPattern *pattern) +{ + XftFontInfo info; + XftFont *font; + + if (!XftFontInfoFill (dpy, pattern, &info)) + return NULL; + + font = XftFontOpenInfo (dpy, pattern, &info); + XftFontInfoEmpty (dpy, &info); + return font; +} + +_X_EXPORT XftFont * +XftFontCopy (Display *dpy, XftFont *public) +{ + XftFontInt *font = (XftFontInt *) public; + + font->ref++; + return public; +} + +static void +XftFontDestroy (Display *dpy, XftFont *public) +{ + XftDisplayInfo *info = _XftDisplayInfoGet (dpy, False); + XftFontInt *font = (XftFontInt *) public; + int i; + + /* note reduction in memory use */ + if (info) + info->glyph_memory -= font->glyph_memory; + /* Clean up the info */ + XftFontInfoEmpty (dpy, &font->info); + /* Free the glyphset */ + if (font->glyphset) + XRenderFreeGlyphSet (dpy, font->glyphset); + /* Free the glyphs */ + for (i = 0; i < font->num_glyphs; i++) + { + XftGlyph *xftg = font->glyphs[i]; + if (xftg) + { + if (xftg->bitmap) + free (xftg->bitmap); + free (xftg); + } + } + + /* Free the pattern and the charset */ + FcPatternDestroy (font->public.pattern); + FcCharSetDestroy (font->public.charset); + + /* Finally, free the font structure */ + XftMemFree (XFT_MEM_FONT, sizeof (XftFontInt) + + font->num_glyphs * sizeof (XftGlyph *) + + font->hash_value * sizeof (XftUcsHash)); + free (font); +} + +static XftFont * +XftFontFindNthUnref (XftDisplayInfo *info, int n) +{ + XftFont *public; + XftFontInt *font; + + for (public = info->fonts; public; public = font->next) + { + font = (XftFontInt*) public; + if (!font->ref && !n--) + break; + } + return public; +} + +_X_HIDDEN void +XftFontManageMemory (Display *dpy) +{ + XftDisplayInfo *info = _XftDisplayInfoGet (dpy, False); + XftFont **prev; + XftFont *public; + XftFontInt *font; + + if (!info) + return; + while (info->num_unref_fonts > info->max_unref_fonts) + { + public = XftFontFindNthUnref (info, rand() % info->num_unref_fonts); + font = (XftFontInt *) public; + + if (XftDebug () & XFT_DBG_CACHE) + printf ("freeing unreferenced font %s/%d size %dx%d\n", + font->info.file->file, font->info.file->id, + (int) font->info.xsize >> 6, (int) font->info.ysize >> 6); + + /* Unhook from display list */ + for (prev = &info->fonts; *prev; prev = &(*(XftFontInt **) prev)->next) + { + if (*prev == public) + { + *prev = font->next; + break; + } + } + /* Unhook from hash list */ + for (prev = &info->fontHash[font->info.hash % XFT_NUM_FONT_HASH]; + *prev; + prev = &(*(XftFontInt **) prev)->hash_next) + { + if (*prev == public) + { + *prev = font->hash_next; + break; + } + } + /* Destroy the font */ + XftFontDestroy (dpy, public); + --info->num_unref_fonts; + } +} + +_X_EXPORT void +XftFontClose (Display *dpy, XftFont *public) +{ + XftDisplayInfo *info = _XftDisplayInfoGet (dpy, False); + XftFontInt *font = (XftFontInt *) public; + + if (--font->ref != 0) + return; + + if (info) + { + ++info->num_unref_fonts; + XftFontManageMemory (dpy); + } + else + { + XftFontDestroy (dpy, public); + } +} + +_X_EXPORT FcBool +XftInitFtLibrary (void) +{ + if (_XftFTlibrary) + return FcTrue; + if (FT_Init_FreeType (&_XftFTlibrary)) + return FcFalse; + return FcTrue; +} diff --git a/libXft/src/xftglyphs.c b/libXft/src/xftglyphs.c new file mode 100644 index 000000000..10adb1587 --- /dev/null +++ b/libXft/src/xftglyphs.c @@ -0,0 +1,827 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" +#include <freetype/ftoutln.h> + +#if HAVE_FT_GLYPHSLOT_EMBOLDEN +#include <freetype/ftsynth.h> +#endif + +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 }, +#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 }, +}; + +/* + * Validate the memory info for a font + */ + +static void +_XftFontValidateMemory (Display *dpy, XftFont *public) +{ + XftFontInt *font = (XftFontInt *) public; + unsigned long glyph_memory; + FT_UInt glyphindex; + XftGlyph *xftg; + + glyph_memory = 0; + for (glyphindex = 0; glyphindex < font->num_glyphs; glyphindex++) + { + xftg = font->glyphs[glyphindex]; + if (xftg) + { + glyph_memory += xftg->glyph_memory; + } + } + if (glyph_memory != font->glyph_memory) + printf ("Font glyph cache incorrect has %ld bytes, should have %ld\n", + font->glyph_memory, glyph_memory); +} + +_X_EXPORT void +XftFontLoadGlyphs (Display *dpy, + XftFont *pub, + FcBool need_bitmaps, + _Xconst FT_UInt *glyphs, + int nglyph) +{ + XftDisplayInfo *info = _XftDisplayInfoGet (dpy, True); + XftFontInt *font = (XftFontInt *) pub; + FT_Error error; + FT_UInt glyphindex; + FT_GlyphSlot glyphslot; + XftGlyph *xftg; + Glyph glyph; + unsigned char bufLocal[4096]; + unsigned char *bufBitmap = bufLocal; + int bufSize = sizeof (bufLocal); + int size, pitch; + unsigned char bufLocalRgba[4096]; + unsigned char *bufBitmapRgba = bufLocalRgba; + int bufSizeRgba = sizeof (bufLocalRgba); + int sizergba, pitchrgba, widthrgba; + int width; + int height; + int left, right, top, bottom; + int hmul = 1; + int vmul = 1; + FT_Bitmap ftbit; + FT_Matrix matrix; + FT_Vector vector; + Bool subpixel = False; + FT_Face face; + + if (!info) + return; + + face = XftLockFace (&font->public); + + if (!face) + return; + + matrix.xx = matrix.yy = 0x10000L; + matrix.xy = matrix.yx = 0; + + if (font->info.antialias) + { + switch (font->info.rgba) { + case FC_RGBA_RGB: + case FC_RGBA_BGR: + matrix.xx *= 3; + subpixel = True; + hmul = 3; + break; + case FC_RGBA_VRGB: + case FC_RGBA_VBGR: + matrix.yy *= 3; + vmul = 3; + subpixel = True; + break; + } + } + + while (nglyph--) + { + glyphindex = *glyphs++; + xftg = font->glyphs[glyphindex]; + if (!xftg) + continue; + + if (XftDebug() & XFT_DBG_CACHE) + _XftFontValidateMemory (dpy, pub); + /* + * Check to see if this glyph has just been loaded, + * this happens when drawing the same glyph twice + * in a single string + */ + if (xftg->glyph_memory) + continue; + + error = FT_Load_Glyph (face, glyphindex, font->info.load_flags); + if (error) + { + /* + * If anti-aliasing or transforming glyphs and + * no outline version exists, fallback to the + * bitmap and let things look bad instead of + * missing the glyph + */ + if (font->info.load_flags & FT_LOAD_NO_BITMAP) + error = FT_Load_Glyph (face, glyphindex, + font->info.load_flags & ~FT_LOAD_NO_BITMAP); + if (error) + continue; + } + +#define FLOOR(x) ((x) & -64) +#define CEIL(x) (((x)+63) & -64) +#define TRUNC(x) ((x) >> 6) +#define ROUND(x) (((x)+32) & -64) + + glyphslot = face->glyph; + +#if HAVE_FT_GLYPHSLOT_EMBOLDEN + /* + * Embolden if required + */ + if (font->info.embolden) FT_GlyphSlot_Embolden(glyphslot); +#endif + + /* + * Compute glyph metrics from FreeType information + */ + if(font->info.transform && glyphslot->format != ft_glyph_format_bitmap) + { + /* + * calculate the true width by transforming all four corners. + */ + int xc, yc; + left = right = top = bottom = 0; + for(xc = 0; xc <= 1; xc ++) { + for(yc = 0; yc <= 1; yc++) { + vector.x = glyphslot->metrics.horiBearingX + xc * glyphslot->metrics.width; + vector.y = glyphslot->metrics.horiBearingY - yc * glyphslot->metrics.height; + FT_Vector_Transform(&vector, &font->info.matrix); + if (XftDebug() & XFT_DBG_GLYPH) + printf("Trans %d %d: %d %d\n", (int) xc, (int) yc, + (int) vector.x, (int) vector.y); + if(xc == 0 && yc == 0) { + left = right = vector.x; + top = bottom = vector.y; + } else { + if(left > vector.x) left = vector.x; + if(right < vector.x) right = vector.x; + if(bottom > vector.y) bottom = vector.y; + if(top < vector.y) top = vector.y; + } + + } + } + left = FLOOR(left); + right = CEIL(right); + bottom = FLOOR(bottom); + top = CEIL(top); + + } else { + left = FLOOR( glyphslot->metrics.horiBearingX ); + right = CEIL( glyphslot->metrics.horiBearingX + glyphslot->metrics.width ); + + top = CEIL( glyphslot->metrics.horiBearingY ); + bottom = FLOOR( glyphslot->metrics.horiBearingY - glyphslot->metrics.height ); + } + + width = TRUNC(right - left); + height = TRUNC( top - bottom ); + + /* + * Clip charcell glyphs to the bounding box + * XXX transformed? + */ + if (font->info.spacing >= FC_CHARCELL && !font->info.transform) + { + if (font->info.load_flags & FT_LOAD_VERTICAL_LAYOUT) + { + if (TRUNC(bottom) > font->public.max_advance_width) + { + int adjust; + + adjust = bottom - (font->public.max_advance_width << 6); + if (adjust > top) + adjust = top; + top -= adjust; + bottom -= adjust; + height = font->public.max_advance_width; + } + } + else + { + if (TRUNC(right) > font->public.max_advance_width) + { + int adjust; + + adjust = right - (font->public.max_advance_width << 6); + if (adjust > left) + adjust = left; + left -= adjust; + right -= adjust; + width = font->public.max_advance_width; + } + } + } + + if (font->info.antialias) + pitch = (width * hmul + 3) & ~3; + else + pitch = ((width + 31) & ~31) >> 3; + + size = pitch * height * vmul; + + xftg->metrics.width = width; + xftg->metrics.height = height; + xftg->metrics.x = -TRUNC(left); + xftg->metrics.y = TRUNC(top); + + if (font->info.spacing >= FC_MONO) + { + if (font->info.transform) + { + if (font->info.load_flags & FT_LOAD_VERTICAL_LAYOUT) + { + vector.x = 0; + vector.y = -face->size->metrics.max_advance; + } + else + { + vector.x = face->size->metrics.max_advance; + vector.y = 0; + } + FT_Vector_Transform (&vector, &font->info.matrix); + xftg->metrics.xOff = vector.x >> 6; + xftg->metrics.yOff = -(vector.y >> 6); + } + else + { + if (font->info.load_flags & FT_LOAD_VERTICAL_LAYOUT) + { + xftg->metrics.xOff = 0; + xftg->metrics.yOff = -font->public.max_advance_width; + } + else + { + xftg->metrics.xOff = font->public.max_advance_width; + xftg->metrics.yOff = 0; + } + } + } + else + { + xftg->metrics.xOff = TRUNC(ROUND(glyphslot->advance.x)); + xftg->metrics.yOff = -TRUNC(ROUND(glyphslot->advance.y)); + } + + /* + * If the glyph is relatively large (> 1% of server memory), + * don't send it until necessary + */ + if (!need_bitmaps && size > info->max_glyph_memory / 100) + continue; + + /* + * Make sure there's enough buffer space for the glyph + */ + if (size > bufSize) + { + if (bufBitmap != bufLocal) + free (bufBitmap); + bufBitmap = (unsigned char *) malloc (size); + if (!bufBitmap) + continue; + bufSize = size; + } + memset (bufBitmap, 0, size); + + /* + * Rasterize into the local buffer + */ + switch (glyphslot->format) { + case ft_glyph_format_outline: + ftbit.width = width * hmul; + ftbit.rows = height * vmul; + ftbit.pitch = pitch; + if (font->info.antialias) + ftbit.pixel_mode = ft_pixel_mode_grays; + else + ftbit.pixel_mode = ft_pixel_mode_mono; + + ftbit.buffer = bufBitmap; + + if (subpixel) + FT_Outline_Transform (&glyphslot->outline, &matrix); + + FT_Outline_Translate ( &glyphslot->outline, -left*hmul, -bottom*vmul ); + + FT_Outline_Get_Bitmap( _XftFTlibrary, &glyphslot->outline, &ftbit ); + break; + case ft_glyph_format_bitmap: + if (font->info.antialias) + { + unsigned char *srcLine, *dstLine; + int height; + int x; + int h, v; + + srcLine = glyphslot->bitmap.buffer; + dstLine = bufBitmap; + height = glyphslot->bitmap.rows; + while (height--) + { + for (x = 0; x < glyphslot->bitmap.width; x++) + { + /* always MSB bitmaps */ + unsigned char a = ((srcLine[x >> 3] & (0x80 >> (x & 7))) ? + 0xff : 0x00); + if (subpixel) + { + for (v = 0; v < vmul; v++) + for (h = 0; h < hmul; h++) + dstLine[v * pitch + x*hmul + h] = a; + } + else + dstLine[x] = a; + } + dstLine += pitch * vmul; + srcLine += glyphslot->bitmap.pitch; + } + } + else + { + unsigned char *srcLine, *dstLine; + int h, bytes; + + srcLine = glyphslot->bitmap.buffer; + dstLine = bufBitmap; + h = glyphslot->bitmap.rows; + bytes = (glyphslot->bitmap.width + 7) >> 3; + while (h--) + { + memcpy (dstLine, srcLine, bytes); + dstLine += pitch; + srcLine += glyphslot->bitmap.pitch; + } + } + break; + default: + if (XftDebug() & XFT_DBG_GLYPH) + printf ("glyph %d is not in a usable format\n", + (int) glyphindex); + continue; + } + + if (XftDebug() & XFT_DBG_GLYPH) + { + printf ("glyph %d:\n", (int) glyphindex); + printf (" xywh (%d %d %d %d), trans (%d %d %d %d) wh (%d %d)\n", + (int) glyphslot->metrics.horiBearingX, + (int) glyphslot->metrics.horiBearingY, + (int) glyphslot->metrics.width, + (int) glyphslot->metrics.height, + left, right, top, bottom, + width, height); + if (XftDebug() & XFT_DBG_GLYPHV) + { + int x, y; + unsigned char *line; + + line = bufBitmap; + for (y = 0; y < height * vmul; y++) + { + if (font->info.antialias) + { + static char den[] = { " .:;=+*#" }; + for (x = 0; x < pitch; x++) + printf ("%c", den[line[x] >> 5]); + } + else + { + for (x = 0; x < pitch * 8; x++) + { + printf ("%c", line[x>>3] & (1 << (x & 7)) ? '#' : ' '); + } + } + printf ("|\n"); + line += pitch; + } + printf ("\n"); + } + } + + /* + * Use the glyph index as the wire encoding; it + * might be more efficient for some locales to map + * these by first usage to smaller values, but that + * would require persistently storing the map when + * glyphs were freed. + */ + glyph = (Glyph) glyphindex; + + if (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; + + /* + * Filter the glyph to soften the color fringes + */ + widthrgba = width; + pitchrgba = (widthrgba * 4 + 3) & ~3; + sizergba = pitchrgba * height; + + os = 1; + switch (font->info.rgba) { + case FC_RGBA_VRGB: + os = pitch; + case FC_RGBA_RGB: + default: + rf = 0; + gf = 1; + bf = 2; + break; + case FC_RGBA_VBGR: + os = pitch; + case FC_RGBA_BGR: + bf = 0; + gf = 1; + rf = 2; + break; + } + if (sizergba > bufSizeRgba) + { + if (bufBitmapRgba != bufLocalRgba) + free (bufBitmapRgba); + bufBitmapRgba = (unsigned char *) malloc (sizergba); + if (!bufBitmapRgba) + continue; + bufSizeRgba = sizergba; + } + memset (bufBitmapRgba, 0, sizergba); + in_line = bufBitmap; + out_line = bufBitmapRgba; + for (y = 0; y < height; y++) + { + in = in_line; + out = (unsigned int *) out_line; + in_line += pitch * vmul; + out_line += pitchrgba; + 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; + } + } + + xftg->glyph_memory = sizergba + sizeof (XftGlyph); + if (font->format) + { + if (!font->glyphset) + font->glyphset = XRenderCreateGlyphSet (dpy, font->format); + if (ImageByteOrder (dpy) != XftNativeByteOrder ()) + XftSwapCARD32 ((CARD32 *) bufBitmapRgba, sizergba >> 2); + XRenderAddGlyphs (dpy, font->glyphset, &glyph, + &xftg->metrics, 1, + (char *) bufBitmapRgba, sizergba); + } + else + { + if (sizergba) + { + xftg->bitmap = malloc (sizergba); + if (xftg->bitmap) + memcpy (xftg->bitmap, bufBitmapRgba, sizergba); + } + else + xftg->bitmap = NULL; + } + } + else + { + xftg->glyph_memory = size + sizeof (XftGlyph); + if (font->format) + { + /* + * swap bit order around; FreeType is always MSBFirst + */ + if (!font->info.antialias) + { + if (BitmapBitOrder (dpy) != MSBFirst) + { + unsigned char *line; + unsigned char c; + int i; + + line = (unsigned char *) bufBitmap; + i = size; + while (i--) + { + c = *line; + c = ((c << 1) & 0xaa) | ((c >> 1) & 0x55); + c = ((c << 2) & 0xcc) | ((c >> 2) & 0x33); + c = ((c << 4) & 0xf0) | ((c >> 4) & 0x0f); + *line++ = c; + } + } + } + if (!font->glyphset) + font->glyphset = XRenderCreateGlyphSet (dpy, font->format); + XRenderAddGlyphs (dpy, font->glyphset, &glyph, + &xftg->metrics, 1, + (char *) bufBitmap, size); + } + else + { + if (size) + { + xftg->bitmap = malloc (size); + if (xftg->bitmap) + memcpy (xftg->bitmap, bufBitmap, size); + } + else + xftg->bitmap = NULL; + } + } + font->glyph_memory += xftg->glyph_memory; + info->glyph_memory += xftg->glyph_memory; + if (XftDebug() & XFT_DBG_CACHE) + _XftFontValidateMemory (dpy, pub); + if (XftDebug() & XFT_DBG_CACHEV) + printf ("Caching glyph 0x%x size %ld\n", glyphindex, + xftg->glyph_memory); + } + if (bufBitmap != bufLocal) + free (bufBitmap); + if (bufBitmapRgba != bufLocalRgba) + free (bufBitmapRgba); + XftUnlockFace (&font->public); +} + +_X_EXPORT void +XftFontUnloadGlyphs (Display *dpy, + XftFont *pub, + _Xconst FT_UInt *glyphs, + int nglyph) +{ + XftDisplayInfo *info = _XftDisplayInfoGet (dpy, False); + XftFontInt *font = (XftFontInt *) pub; + XftGlyph *xftg; + FT_UInt glyphindex; + Glyph glyphBuf[1024]; + int nused; + + nused = 0; + while (nglyph--) + { + glyphindex = *glyphs++; + xftg = font->glyphs[glyphindex]; + if (!xftg) + continue; + if (xftg->glyph_memory) + { + if (font->format) + { + if (font->glyphset) + { + glyphBuf[nused++] = (Glyph) glyphindex; + if (nused == sizeof (glyphBuf) / sizeof (glyphBuf[0])) + { + XRenderFreeGlyphs (dpy, font->glyphset, glyphBuf, nused); + nused = 0; + } + } + } + else + { + if (xftg->bitmap) + free (xftg->bitmap); + } + font->glyph_memory -= xftg->glyph_memory; + if (info) + info->glyph_memory -= xftg->glyph_memory; + } + free (xftg); + XftMemFree (XFT_MEM_GLYPH, sizeof (XftGlyph)); + font->glyphs[glyphindex] = NULL; + } + if (font->glyphset && nused) + XRenderFreeGlyphs (dpy, font->glyphset, glyphBuf, nused); +} + +_X_EXPORT FcBool +XftFontCheckGlyph (Display *dpy, + XftFont *pub, + FcBool need_bitmaps, + FT_UInt glyph, + FT_UInt *missing, + int *nmissing) +{ + XftFontInt *font = (XftFontInt *) pub; + XftGlyph *xftg; + int n; + + if (glyph >= font->num_glyphs) + return FcFalse; + xftg = font->glyphs[glyph]; + if (!xftg || (need_bitmaps && !xftg->glyph_memory)) + { + if (!xftg) + { + xftg = (XftGlyph *) malloc (sizeof (XftGlyph)); + if (!xftg) + return FcFalse; + XftMemAlloc (XFT_MEM_GLYPH, sizeof (XftGlyph)); + xftg->bitmap = NULL; + xftg->glyph_memory = 0; + font->glyphs[glyph] = xftg; + } + n = *nmissing; + missing[n++] = glyph; + if (n == XFT_NMISSING) + { + XftFontLoadGlyphs (dpy, pub, need_bitmaps, missing, n); + n = 0; + } + *nmissing = n; + return FcTrue; + } + else + return FcFalse; +} + +_X_EXPORT FcBool +XftCharExists (Display *dpy, + XftFont *pub, + FcChar32 ucs4) +{ + if (pub->charset) + return FcCharSetHasChar (pub->charset, ucs4); + return FcFalse; +} + +#define Missing ((FT_UInt) ~0) + +_X_EXPORT FT_UInt +XftCharIndex (Display *dpy, + XftFont *pub, + FcChar32 ucs4) +{ + XftFontInt *font = (XftFontInt *) pub; + FcChar32 ent, offset; + FT_Face face; + + if (!font->hash_value) + return 0; + + ent = ucs4 % font->hash_value; + offset = 0; + while (font->hash_table[ent].ucs4 != ucs4) + { + if (font->hash_table[ent].ucs4 == (FcChar32) ~0) + { + if (!XftCharExists (dpy, pub, ucs4)) + return 0; + face = XftLockFace (pub); + if (!face) + return 0; + font->hash_table[ent].ucs4 = ucs4; + font->hash_table[ent].glyph = FcFreeTypeCharIndex (face, ucs4); + XftUnlockFace (pub); + break; + } + if (!offset) + { + offset = ucs4 % font->rehash_value; + if (!offset) + offset = 1; + } + ent = ent + offset; + if (ent >= font->hash_value) + ent -= font->hash_value; + } + return font->hash_table[ent].glyph; +} + +/* + * Pick a random glyph from the font and remove it from the cache + */ +_X_HIDDEN void +_XftFontUncacheGlyph (Display *dpy, XftFont *pub) +{ + XftFontInt *font = (XftFontInt *) pub; + unsigned long glyph_memory; + FT_UInt glyphindex; + XftGlyph *xftg; + + if (!font->glyph_memory) + return; + if (font->use_free_glyphs) + { + glyph_memory = rand() % font->glyph_memory; + } + else + { + if (font->glyphset) + { + XRenderFreeGlyphSet (dpy, font->glyphset); + font->glyphset = 0; + } + glyph_memory = 0; + } + + if (XftDebug() & XFT_DBG_CACHE) + _XftFontValidateMemory (dpy, pub); + for (glyphindex = 0; glyphindex < font->num_glyphs; glyphindex++) + { + xftg = font->glyphs[glyphindex]; + if (xftg) + { + if (xftg->glyph_memory > glyph_memory) + { + if (XftDebug() & XFT_DBG_CACHEV) + printf ("Uncaching glyph 0x%x size %ld\n", + glyphindex, xftg->glyph_memory); + XftFontUnloadGlyphs (dpy, pub, &glyphindex, 1); + if (!font->use_free_glyphs) + continue; + break; + } + glyph_memory -= xftg->glyph_memory; + } + } + if (XftDebug() & XFT_DBG_CACHE) + _XftFontValidateMemory (dpy, pub); +} + +_X_HIDDEN void +_XftFontManageMemory (Display *dpy, XftFont *pub) +{ + XftFontInt *font = (XftFontInt *) pub; + + if (font->max_glyph_memory) + { + if (XftDebug() & XFT_DBG_CACHE) + { + if (font->glyph_memory > font->max_glyph_memory) + printf ("Reduce memory for font 0x%lx from %ld to %ld\n", + font->glyphset ? font->glyphset : (unsigned long) font, + font->glyph_memory, font->max_glyph_memory); + } + while (font->glyph_memory > font->max_glyph_memory) + _XftFontUncacheGlyph (dpy, pub); + } + _XftDisplayManageMemory (dpy); +} diff --git a/libXft/src/xftinit.c b/libXft/src/xftinit.c new file mode 100644 index 000000000..43efc00e1 --- /dev/null +++ b/libXft/src/xftinit.c @@ -0,0 +1,113 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +static Bool _XftConfigInitialized; + +_X_EXPORT Bool +XftInit (_Xconst char *config) +{ + if (_XftConfigInitialized) + return True; + _XftConfigInitialized = True; + if (!FcInit ()) + return False; + _XftNameInit (); + return True; +} + +_X_EXPORT int +XftGetVersion (void) +{ + return XftVersion; +} + +static struct { + char *name; + int alloc_count; + int alloc_mem; + int free_count; + int free_mem; +} XftInUse[XFT_MEM_NUM] = { + { "XftDraw", 0, 0 }, + { "XftFont", 0 ,0 }, + { "XftFtFile", 0, 0 }, + { "XftGlyph", 0, 0 }, +}; + +static int XftAllocCount, XftAllocMem; +static int XftFreeCount, XftFreeMem; + +static int XftMemNotice = 1*1024*1024; + +static int XftAllocNotify, XftFreeNotify; + +_X_HIDDEN void +XftMemReport (void) +{ + int i; + printf ("Xft Memory Usage:\n"); + printf ("\t Which Alloc Free\n"); + printf ("\t count bytes count bytes\n"); + for (i = 0; i < XFT_MEM_NUM; i++) + printf ("\t%8.8s%8d%8d%8d%8d\n", + XftInUse[i].name, + XftInUse[i].alloc_count, XftInUse[i].alloc_mem, + XftInUse[i].free_count, XftInUse[i].free_mem); + printf ("\t%8.8s%8d%8d%8d%8d\n", + "Total", + XftAllocCount, XftAllocMem, + XftFreeCount, XftFreeMem); + XftAllocNotify = 0; + XftFreeNotify = 0; +} + +_X_HIDDEN void +XftMemAlloc (int kind, int size) +{ + if (XftDebug() & XFT_DBG_MEMORY) + { + XftInUse[kind].alloc_count++; + XftInUse[kind].alloc_mem += size; + XftAllocCount++; + XftAllocMem += size; + XftAllocNotify += size; + if (XftAllocNotify > XftMemNotice) + XftMemReport (); + } +} + +_X_HIDDEN void +XftMemFree (int kind, int size) +{ + if (XftDebug() & XFT_DBG_MEMORY) + { + XftInUse[kind].free_count++; + XftInUse[kind].free_mem += size; + XftFreeCount++; + XftFreeMem += size; + XftFreeNotify += size; + if (XftFreeNotify > XftMemNotice) + XftMemReport (); + } +} diff --git a/libXft/src/xftint.h b/libXft/src/xftint.h new file mode 100644 index 000000000..3aafecf86 --- /dev/null +++ b/libXft/src/xftint.h @@ -0,0 +1,465 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * These definitions are solely for use by the implementation of Xft + * and constitute no kind of standard. If you need any of these functions, + * please drop me a note. Either the library needs new functionality, + * or there's a way to do what you need using the existing published + * interfaces. keithp@freedesktop.org + */ + +#ifndef _XFTINT_H_ +#define _XFTINT_H_ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#else /* X monolithic tree */ +#define HAVE_STDLIB_H 1 /* assumed since all ANSI C platforms require it */ +#include <X11/Xosdefs.h> /* get string.h or strings.h as appropriate */ +#endif + +#include <stdio.h> +#if HAVE_STDLIB_H +#include <stdlib.h> +#endif +#if HAVE_STRING_H +#include <string.h> +#else +#if HAVE_STRINGS_H +#include <strings.h> +#endif +#endif +#include <ctype.h> + +#include <X11/Xlib.h> +#include <X11/Xutil.h> +#include <X11/Xmd.h> +#include <X11/Xlibint.h> +#define _XFT_NO_COMPAT_ +#include "Xft.h" +#include <fontconfig/fcprivate.h> +#include <fontconfig/fcfreetype.h> + +/* Added to <X11/Xfuncproto.h> in X11R6.9 and later */ +#ifndef _X_HIDDEN +# define _X_HIDDEN /**/ +#endif +#ifndef _X_EXPORT +# define _X_EXPORT /**/ +#endif + +#ifndef HAVE_CONFIG_H +# if (FREETYPE_MAJOR > 2 || \ + (FREETYPE_MAJOR == 2 && (FREETYPE_MINOR > 1 || \ + (FREETYPE_MINOR == 1 && FREETYPE_PATCH >= 5)))) +# define HAVE_FT_BITMAP_SIZE_Y_PPEM 1 +# else +# define HAVE_FT_BITMAP_SIZE_Y_PPEM 0 +# endif +#endif + +typedef struct _XftMatcher { + char *object; + double (*compare) (char *object, FcValue value1, FcValue value2); +} XftMatcher; + +typedef struct _XftSymbolic { + const char *name; + int value; +} XftSymbolic; + +/* + * Glyphs are stored in this structure + */ +typedef struct _XftGlyph { + XGlyphInfo metrics; + void *bitmap; + unsigned long glyph_memory; +} XftGlyph; + +/* + * A hash table translates Unicode values into glyph indicies + */ +typedef struct _XftUcsHash { + FcChar32 ucs4; + FT_UInt glyph; +} XftUcsHash; + +/* + * Many fonts can share the same underlying face data; this + * structure references that. Note that many faces may in fact + * live in the same font file; that is irrelevant to this structure + * which is concerned only with the individual faces themselves + */ + +typedef struct _XftFtFile { + struct _XftFtFile *next; + int ref; /* number of font infos using this file */ + + char *file; /* file name */ + int id; /* font index within that file */ + + FT_F26Dot6 xsize; /* current xsize setting */ + FT_F26Dot6 ysize; /* current ysize setting */ + FT_Matrix matrix; /* current matrix setting */ + + int lock; /* lock count; can't unload unless 0 */ + FT_Face face; /* pointer to face; only valid when lock */ +} XftFtFile; + +/* + * This structure holds the data extracted from a pattern + * needed to create a unique font object. + */ + +struct _XftFontInfo { + /* + * Hash value (not include in hash value computation) + */ + FcChar32 hash; + XftFtFile *file; /* face source */ + /* + * Rendering options + */ + FT_F26Dot6 xsize, ysize; /* pixel size */ + FcBool antialias; /* doing antialiasing */ + FcBool embolden; /* force emboldening */ + int rgba; /* subpixel order */ + FT_Matrix matrix; /* glyph transformation matrix */ + FcBool transform; /* non-identify matrix? */ + FT_Int load_flags; /* glyph load flags */ + FcBool render; /* whether to use the Render extension */ + /* + * Internal fields + */ + int spacing; + FcBool minspace; + int char_width; +}; + +/* + * Internal version of the font with private data + */ + +typedef struct _XftFontInt { + XftFont public; /* public fields */ + XftFont *next; /* all fonts on display */ + XftFont *hash_next; /* fonts in this hash chain */ + XftFontInfo info; /* Data from pattern */ + int ref; /* reference count */ + /* + * Per-glyph information, indexed by glyph ID + * This array follows the font in memory + */ + XftGlyph **glyphs; + int num_glyphs; /* size of glyphs/bitmaps arrays */ + /* + * Hash table to get from Unicode value to glyph ID + * This array follows the glyphs in memory + */ + XftUcsHash *hash_table; + int hash_value; + int rehash_value; + /* + * X specific fields + */ + GlyphSet glyphset; /* Render glyphset */ + XRenderPictFormat *format; /* Render format for glyphs */ + /* + * Glyph memory management fields + */ + unsigned long glyph_memory; + unsigned long max_glyph_memory; + FcBool use_free_glyphs; /* Use XRenderFreeGlyphs */ +} XftFontInt; + +typedef enum _XftClipType { + XftClipTypeNone, XftClipTypeRegion, XftClipTypeRectangles +} XftClipType; + +typedef struct _XftClipRect { + int xOrigin; + int yOrigin; + int n; +} XftClipRect; + +#define XftClipRects(cr) ((XRectangle *) ((cr) + 1)) + +typedef union _XftClip { + XftClipRect *rect; + Region region; +} XftClip; + +struct _XftDraw { + Display *dpy; + int screen; + unsigned int bits_per_pixel; + unsigned int depth; + Drawable drawable; + Visual *visual; /* NULL for bitmaps */ + Colormap colormap; + XftClipType clip_type; + XftClip clip; + int subwindow_mode; + struct { + Picture pict; + } render; + struct { + GC gc; + int use_pixmap; + } core; +}; + +/* + * Instead of taking two round trips for each blending request, + * assume that if a particular drawable fails GetImage that it will + * fail for a "while"; use temporary pixmaps to avoid the errors + */ + +#define XFT_ASSUME_PIXMAP 20 + +typedef struct _XftSolidColor { + XRenderColor color; + int screen; + Picture pict; +} XftSolidColor; + +#define XFT_NUM_SOLID_COLOR 16 + +#define XFT_NUM_FONT_HASH 127 + +typedef struct _XftDisplayInfo { + struct _XftDisplayInfo *next; + Display *display; + XExtCodes *codes; + FcPattern *defaults; + FcBool hasRender; + XftFont *fonts; + XRenderPictFormat *solidFormat; + unsigned long glyph_memory; + unsigned long max_glyph_memory; + FcBool use_free_glyphs; + int num_unref_fonts; + int max_unref_fonts; + XftSolidColor colors[XFT_NUM_SOLID_COLOR]; + XftFont *fontHash[XFT_NUM_FONT_HASH]; +} XftDisplayInfo; + +/* + * By default, use no more than 4 meg of server memory total, and no + * more than 1 meg for any one font + */ +#define XFT_DPY_MAX_GLYPH_MEMORY (4 * 1024 * 1024) +#define XFT_FONT_MAX_GLYPH_MEMORY (1024 * 1024) + +/* + * By default, keep the last 16 unreferenced fonts around to + * speed reopening them. Note that the glyph caching code + * will keep the global memory usage reasonably limited + */ +#define XFT_DPY_MAX_UNREF_FONTS 16 + +extern XftDisplayInfo *_XftDisplayInfo; + +#define XFT_DBG_OPEN 1 +#define XFT_DBG_OPENV 2 +#define XFT_DBG_RENDER 4 +#define XFT_DBG_DRAW 8 +#define XFT_DBG_REF 16 +#define XFT_DBG_GLYPH 32 +#define XFT_DBG_GLYPHV 64 +#define XFT_DBG_CACHE 128 +#define XFT_DBG_CACHEV 256 +#define XFT_DBG_MEMORY 512 + +#define XFT_MEM_DRAW 0 +#define XFT_MEM_FONT 1 +#define XFT_MEM_FILE 2 +#define XFT_MEM_GLYPH 3 +#define XFT_MEM_NUM 4 + +/* xftcompat.c */ +void XftFontSetDestroy (FcFontSet *s); +FcBool XftMatrixEqual (_Xconst FcMatrix *mat1, _Xconst FcMatrix *mat2); +void XftMatrixMultiply (FcMatrix *result, FcMatrix *a, FcMatrix *b); +void XftMatrixRotate (FcMatrix *m, double c, double s); +void XftMatrixScale (FcMatrix *m, double sx, double sy); +void XftMatrixShear (FcMatrix *m, double sh, double sv); +FcPattern *XftPatternCreate (void); +void XftValueDestroy (FcValue v); +void XftPatternDestroy (FcPattern *p); +FcBool XftPatternAdd (FcPattern *p, _Xconst char *object, FcValue value, FcBool append); +FcBool XftPatternDel (FcPattern *p, _Xconst char *object); +FcBool XftPatternAddInteger (FcPattern *p, _Xconst char *object, int i); +FcBool XftPatternAddDouble (FcPattern *p, _Xconst char *object, double i); +FcBool XftPatternAddMatrix (FcPattern *p, _Xconst char *object, FcMatrix *i); +FcBool XftPatternAddString (FcPattern *p, _Xconst char *object, char *i); +FcBool XftPatternAddBool (FcPattern *p, _Xconst char *object, FcBool i); +FcResult XftPatternGet (FcPattern *p, _Xconst char *object, int id, FcValue *v); +FcResult XftPatternGetInteger (FcPattern *p, _Xconst char *object, int id, int *i); +FcResult XftPatternGetDouble (FcPattern *p, _Xconst char *object, int id, double *i); +FcResult XftPatternGetString (FcPattern *p, _Xconst char *object, int id, char **i); +FcResult XftPatternGetMatrix (FcPattern *p, _Xconst char *object, int id, FcMatrix **i); +FcResult XftPatternGetBool (FcPattern *p, _Xconst char *object, int id, FcBool *i); +FcPattern *XftPatternDuplicate (FcPattern *orig); +FcPattern *XftPatternVaBuild (FcPattern *orig, va_list va); +FcPattern *XftPatternBuild (FcPattern *orig, ...); +FcBool XftNameUnparse (FcPattern *pat, char *dest, int len); +FcBool XftGlyphExists (Display *dpy, XftFont *font, FcChar32 ucs4); +FcObjectSet *XftObjectSetCreate (void); +Bool XftObjectSetAdd (FcObjectSet *os, _Xconst char *object); +void XftObjectSetDestroy (FcObjectSet *os); +FcObjectSet *XftObjectSetVaBuild (_Xconst char *first, va_list va); +FcObjectSet *XftObjectSetBuild (_Xconst char *first, ...); +FcFontSet *XftListFontSets (FcFontSet **sets, int nsets, FcPattern *p, FcObjectSet *os); + +/* xftcore.c */ +void +XftRectCore (XftDraw *draw, + _Xconst XftColor *color, + int x, + int y, + unsigned int width, + unsigned int height); + +void +XftGlyphCore (XftDraw *draw, + _Xconst XftColor *color, + XftFont *public, + int x, + int y, + _Xconst FT_UInt *glyphs, + int nglyphs); + +void +XftGlyphSpecCore (XftDraw *draw, + _Xconst XftColor *color, + XftFont *public, + _Xconst XftGlyphSpec *glyphs, + int nglyphs); + +void +XftGlyphFontSpecCore (XftDraw *draw, + _Xconst XftColor *color, + _Xconst XftGlyphFontSpec *glyphs, + int nglyphs); + +/* xftdbg.c */ +int +XftDebug (void); + +/* xftdpy.c */ +XftDisplayInfo * +_XftDisplayInfoGet (Display *dpy, FcBool createIfNecessary); + +void +_XftDisplayManageMemory (Display *dpy); + +int +XftDefaultParseBool (char *v); + +FcBool +XftDefaultGetBool (Display *dpy, const char *object, int screen, FcBool def); + +int +XftDefaultGetInteger (Display *dpy, const char *object, int screen, int def); + +double +XftDefaultGetDouble (Display *dpy, const char *object, int screen, double def); + +FcFontSet * +XftDisplayGetFontSet (Display *dpy); + +/* xftdraw.c */ +unsigned int +XftDrawDepth (XftDraw *draw); + +unsigned int +XftDrawBitsPerPixel (XftDraw *draw); + +FcBool +XftDrawRenderPrepare (XftDraw *draw); + +/* xftextent.c */ + +/* xftfont.c */ + +/* xftfreetype.c */ +FcBool +_XftSetFace (XftFtFile *f, FT_F26Dot6 xsize, FT_F26Dot6 ysize, FT_Matrix *matrix); + +void +XftFontManageMemory (Display *dpy); + +/* xftglyph.c */ +void +_XftFontUncacheGlyph (Display *dpy, XftFont *public); + +void +_XftFontManageMemory (Display *dpy, XftFont *public); + +/* xftinit.c */ +void +XftMemReport (void); + +void +XftMemAlloc (int kind, int size); + +void +XftMemFree (int kind, int size); + +/* xftlist.c */ +FcFontSet * +XftListFontsPatternObjects (Display *dpy, + int screen, + FcPattern *pattern, + FcObjectSet *os); + +/* xftname.c */ +void +_XftNameInit (void); + +/* xftrender.c */ + +/* xftstr.c */ +int +_XftMatchSymbolic (XftSymbolic *s, int n, const char *name, int def); + +/* xftswap.c */ +int +XftNativeByteOrder (void); + +void +XftSwapCARD32 (CARD32 *data, int n); + +void +XftSwapCARD24 (CARD8 *data, int width, int height); + +void +XftSwapCARD16 (CARD16 *data, int n); + +void +XftSwapImage (XImage *image); + +/* xftxlfd.c */ +#endif /* _XFT_INT_H_ */ diff --git a/libXft/src/xftlist.c b/libXft/src/xftlist.c new file mode 100644 index 000000000..0780f7ca8 --- /dev/null +++ b/libXft/src/xftlist.c @@ -0,0 +1,58 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +_X_HIDDEN FcFontSet * +XftListFontsPatternObjects (Display *dpy, + int screen, + FcPattern *pattern, + FcObjectSet *os) +{ + return FcFontList (NULL, pattern, os); +} + +_X_EXPORT FcFontSet * +XftListFonts (Display *dpy, + int screen, + ...) +{ + va_list va; + FcFontSet *fs; + FcObjectSet *os; + FcPattern *pattern; + const char *first; + + va_start (va, screen); + + FcPatternVapBuild (pattern, NULL, va); + + first = va_arg (va, const char *); + FcObjectSetVapBuild (os, first, va); + + va_end (va); + + fs = XftListFontsPatternObjects (dpy, screen, pattern, os); + FcPatternDestroy (pattern); + FcObjectSetDestroy (os); + return fs; +} diff --git a/libXft/src/xftname.c b/libXft/src/xftname.c new file mode 100644 index 000000000..a0c6be704 --- /dev/null +++ b/libXft/src/xftname.c @@ -0,0 +1,82 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +static const FcObjectType _XftObjectTypes[] = { + { XFT_CORE, FcTypeBool, }, + { XFT_XLFD, FcTypeString, }, + { XFT_RENDER, FcTypeBool, }, + { XFT_MAX_GLYPH_MEMORY, FcTypeInteger, }, +}; + +#define NUM_OBJECT_TYPES (sizeof _XftObjectTypes / sizeof _XftObjectTypes[0]) + +static FcBool _XftNameInitialized; + +_X_HIDDEN void +_XftNameInit (void) +{ + if (_XftNameInitialized) + return; + _XftNameInitialized = FcTrue; + FcNameRegisterObjectTypes (_XftObjectTypes, NUM_OBJECT_TYPES); +} + +_X_EXPORT FcPattern +*XftNameParse (const char *name) +{ + _XftNameInit (); + return FcNameParse ((FcChar8 *) name); +} + +_X_EXPORT FcBool +XftNameUnparse (FcPattern *pat, char *dest, int len) +{ + FcChar8 *name; + + _XftNameInit (); + name = FcNameUnparse (pat); + if (!name) + return FcFalse; + if (strlen ((char *) name) + 1 > len) + { + FcPattern *new = FcPatternDuplicate (pat); + free (name); + FcPatternDel (new, FC_LANG); + FcPatternDel (new, FC_CHARSET); + name = FcNameUnparse (new); + FcPatternDestroy (new); + if (!name) + return FcFalse; + if (strlen ((char *) name) + 1 > len) + { + strncpy (dest, ((char *) name), (size_t) len - 1); + dest[len - 1] = '\0'; + free (name); + return FcFalse; + } + } + strcpy (dest, ((char *) name)); + free (name); + return FcTrue; +} diff --git a/libXft/src/xftrender.c b/libXft/src/xftrender.c new file mode 100644 index 000000000..94c211bde --- /dev/null +++ b/libXft/src/xftrender.c @@ -0,0 +1,1007 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +#define NUM_LOCAL 1024 +#define NUM_ELT_LOCAL 128 + +/* + * Use the Render extension to draw the glyphs + */ + +_X_EXPORT void +XftGlyphRender (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FT_UInt *glyphs, + int nglyphs) +{ + XftFontInt *font = (XftFontInt *) pub; + int i; + FT_UInt missing[XFT_NMISSING]; + int nmissing; + FT_UInt g, max; + int size, width; + Glyph wire; + char *char8; + unsigned short *char16; + unsigned int *char32; + unsigned int char_local[NUM_LOCAL]; + unsigned int *chars; + FcBool glyphs_loaded; + + if (!font->format) + return; + + /* + * Load missing glyphs + */ + nmissing = 0; + max = 0; + glyphs_loaded = FcFalse; + for (i = 0; i < nglyphs; i++) + { + g = glyphs[i]; + if (g > max) + max = g; + if (XftFontCheckGlyph (dpy, pub, FcTrue, g, missing, &nmissing)) + glyphs_loaded = FcTrue; + } + if (nmissing) + XftFontLoadGlyphs (dpy, pub, FcTrue, missing, nmissing); + + if (!font->glyphset) + goto bail1; + if (max < 0x100) + { + width = 1; + size = sizeof (char); + } + else if (max < 0x10000) + { + width = 2; + size = sizeof (unsigned short); + } + else + { + width = 4; + size = sizeof (unsigned int); + } + chars = char_local; + if (nglyphs * size > sizeof (char_local)) + { + chars = malloc (nglyphs * size); + if (!chars) + goto bail1; + } + char8 = (char *) chars; + char16 = (unsigned short *) chars; + char32 = (unsigned int *) chars; + for (i = 0; i < nglyphs; i++) + { + wire = (Glyph) glyphs[i]; + if (wire >= font->num_glyphs || !font->glyphs[wire]) + wire = 0; + switch (width) { + case 1: char8[i] = (char) wire; break; + case 2: char16[i] = (unsigned short) wire; break; + case 4: char32[i] = (unsigned long) wire; break; + } + } + switch (width) { + case 1: + default: + XRenderCompositeString8 (dpy, op, + src, dst, font->format, font->glyphset, + srcx, srcy, x, y, char8, nglyphs); + break; + case 2: + XRenderCompositeString16(dpy, op, + src, dst, font->format, font->glyphset, + srcx, srcy, x, y, char16, nglyphs); + break; + case 4: + XRenderCompositeString32(dpy, op, + src, dst, font->format, font->glyphset, + srcx, srcy, x, y, char32, nglyphs); + break; + } + if (chars != char_local) + free (chars); +bail1: + if (glyphs_loaded) + _XftFontManageMemory (dpy, pub); +} + +_X_EXPORT void +XftGlyphSpecRender (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + _Xconst XftGlyphSpec *glyphs, + int nglyphs) +{ + XftFontInt *font = (XftFontInt *) pub; + int i, j; + FT_UInt missing[XFT_NMISSING]; + int nmissing; + int n; + FT_UInt g; + XftGlyph *glyph; + FT_UInt max; + int size, width; + char *char8; + unsigned short *char16; + unsigned int *char32; + unsigned int char_local[NUM_LOCAL]; + unsigned int *chars; + XGlyphElt8 *elts; + XGlyphElt8 elts_local[NUM_ELT_LOCAL]; + FcBool glyphs_loaded; + int nelt; + int x, y; + + if (!font->format) + return; + if (!nglyphs) + return; + + /* + * Load missing glyphs + */ + max = 0; + nmissing = 0; + glyphs_loaded = FcFalse; + g = glyphs[0].glyph; + for (i = 0; i < nglyphs; i++) + { + g = glyphs[i].glyph; + if (g > max) + max = g; + if (XftFontCheckGlyph (dpy, pub, FcTrue, g, missing, &nmissing)) + glyphs_loaded = FcTrue; + } + if (nmissing) + XftFontLoadGlyphs (dpy, pub, FcTrue, missing, nmissing); + + if (!font->glyphset) + goto bail1; + + /* + * See what encoding size is needed + */ + if (max < 0x100) + { + size = sizeof (char); + width = 1; + } + else if (max < 0x10000) + { + size = sizeof (unsigned short); + width = 2; + } + else + { + size = sizeof (unsigned int); + width = 4; + } + chars = char_local; + if (nglyphs * size > NUM_LOCAL) + { + chars = malloc (nglyphs * size); + if (!chars) + goto bail1; + } + char8 = (char *) chars; + char16 = (unsigned short *) chars; + char32 = (unsigned int *) chars; + + /* + * Compute the number of glyph elts needed + */ + nelt = 1; + for (i = 0; i < nglyphs; i++) + { + g = glyphs[i].glyph; + /* Substitute default for non-existant glyphs */ + if (g >= font->num_glyphs || !font->glyphs[g]) + g = 0; + if (font->glyphs[g]) + break; + } + if (i == nglyphs) + goto bail2; + glyph = font->glyphs[g]; + x = glyphs[i].x + glyph->metrics.xOff; + y = glyphs[i].y + glyph->metrics.yOff; + while (++i < nglyphs) + { + g = glyphs[i].glyph; + /* Substitute default for non-existant glyphs */ + if (g >= font->num_glyphs || !font->glyphs[g]) + g = 0; + /* + * check to see if the glyph is placed where it would + * fall using the normal spacing + */ + if ((glyph = font->glyphs[g])) + { + if (x != glyphs[i].x || y != glyphs[i].y) + { + x = glyphs[i].x; + y = glyphs[i].y; + ++nelt; + } + x += glyph->metrics.xOff; + y += glyph->metrics.yOff; + } + } + + elts = elts_local; + if (nelt > NUM_ELT_LOCAL) + { + elts = malloc (nelt * sizeof (XGlyphElt8)); + if (!elts) + goto bail2; + } + + /* + * Generate the list of glyph elts + */ + nelt = 0; + x = y = 0; + n = 0; + j = 0; + for (i = 0; i < nglyphs; i++) + { + g = glyphs[i].glyph; + /* Substitute default for non-existant glyphs */ + if (g >= font->num_glyphs || !font->glyphs[g]) + g = 0; + if ((glyph = font->glyphs[g])) + { + if (!i || x != glyphs[i].x || y != glyphs[i].y) + { + if (n) + { + elts[nelt].nchars = n; + nelt++; + } + elts[nelt].glyphset = font->glyphset; + elts[nelt].chars = char8 + size * j; + elts[nelt].xOff = glyphs[i].x - x; + elts[nelt].yOff = glyphs[i].y - y; + x = glyphs[i].x; + y = glyphs[i].y; + n = 0; + } + switch (width) { + case 1: char8[j] = (char) g; break; + case 2: char16[j] = (unsigned short) g; break; + case 4: char32[j] = (unsigned int) g; break; + } + x += glyph->metrics.xOff; + y += glyph->metrics.yOff; + j++; + n++; + } + } + if (n) + { + elts[nelt].nchars = n; + nelt++; + } + switch (width) { + case 1: + XRenderCompositeText8 (dpy, op, src, dst, font->format, + srcx, srcy, glyphs[0].x, glyphs[0].y, + elts, nelt); + break; + case 2: + XRenderCompositeText16 (dpy, op, src, dst, font->format, + srcx, srcy, glyphs[0].x, glyphs[0].y, + (XGlyphElt16 *) elts, nelt); + break; + case 4: + XRenderCompositeText32 (dpy, op, src, dst, font->format, + srcx, srcy, glyphs[0].x, glyphs[0].y, + (XGlyphElt32 *) elts, nelt); + break; + } + + if (elts != elts_local) + free (elts); +bail2: + if (chars != char_local) + free (chars); +bail1: + if (glyphs_loaded) + _XftFontManageMemory (dpy, pub); +} + +_X_EXPORT void +XftCharSpecRender (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + _Xconst XftCharSpec *chars, + int len) +{ + XftGlyphSpec *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (XftGlyphSpec)); + if (!glyphs) + return; + } + for (i = 0; i < len; i++) + { + glyphs[i].glyph = XftCharIndex(dpy, pub, chars[i].ucs4); + glyphs[i].x = chars[i].x; + glyphs[i].y = chars[i].y; + } + + XftGlyphSpecRender (dpy, op, src, pub, dst, srcx, srcy, glyphs, len); + + if (glyphs != glyphs_local) + free (glyphs); +} + +/* + * Choose which format to draw text in when drawing with fonts + * of different formats. The trick is that ARGB formats aren't + * compatible with A formats as PictOpAdd does the wrong thing, so + * fall back to an A format when presented with an ARGB and A format + */ + +#define XftIsARGBFormat(a) ((a)->depth == 32) + +static XRenderPictFormat * +XftPreferFormat (Display *dpy, XRenderPictFormat *a, XRenderPictFormat *b) +{ + XRenderPictFormat *prefer = NULL; + + if (a == b) + prefer = a; + else if (XftIsARGBFormat(a) != XftIsARGBFormat(b)) + prefer = XRenderFindStandardFormat (dpy, PictStandardA8); + else if (a->depth > b->depth) + prefer = a; + else + prefer = b; + return prefer; +} + +_X_EXPORT void +XftGlyphFontSpecRender (Display *dpy, + int op, + Picture src, + Picture dst, + int srcx, + int srcy, + _Xconst XftGlyphFontSpec *glyphs, + int nglyphs) +{ + int i, j; + XftFont *prevPublic; + XftFontInt *firstFont; + XRenderPictFormat *format; + FT_UInt missing[XFT_NMISSING]; + int nmissing; + int n; + FT_UInt g; + XftGlyph *glyph; + FT_UInt max; + int size, width; + char *char8; + unsigned short *char16; + unsigned int *char32; + unsigned int char_local[NUM_LOCAL]; + unsigned int *chars; + XGlyphElt8 *elts; + XGlyphElt8 elts_local[NUM_ELT_LOCAL]; + FcBool glyphs_loaded; + int nelt; + int x, y; + + if (!nglyphs) + return; + + /* + * Load missing glyphs. Have to load them + * one at a time in case the font changes + */ + max = 0; + glyphs_loaded = FcFalse; + g = glyphs[0].glyph; + for (i = 0; i < nglyphs; i++) + { + XftFont *pub = glyphs[i].font; + XftFontInt *font = (XftFontInt *) pub; + g = glyphs[i].glyph; + if (g > max) + max = g; + nmissing = 0; + if (XftFontCheckGlyph (dpy, pub, FcTrue, g, missing, &nmissing)) + glyphs_loaded = FcTrue; + if (nmissing) + XftFontLoadGlyphs (dpy, pub, FcTrue, missing, nmissing); + if (!font->format) + goto bail1; + if (!font->glyphset) + goto bail1; + } + + /* + * See what encoding size is needed + */ + if (max < 0x100) + { + size = sizeof (char); + width = 1; + } + else if (max < 0x10000) + { + size = sizeof (unsigned short); + width = 2; + } + else + { + size = sizeof (unsigned int); + width = 4; + } + chars = char_local; + if (nglyphs * size > NUM_LOCAL) + { + chars = malloc (nglyphs * size); + if (!chars) + goto bail1; + } + char8 = (char *) chars; + char16 = (unsigned short *) chars; + char32 = (unsigned int *) chars; + + /* + * Compute the number of glyph elts needed + */ + nelt = 1; + firstFont = NULL; + for (i = 0; i < nglyphs; i++) + { + XftFont *pub = glyphs[i].font; + XftFontInt *font = (XftFontInt *) pub; + g = glyphs[i].glyph; + /* Substitute default for non-existant glyphs */ + if (g >= font->num_glyphs || !font->glyphs[g]) + g = 0; + if (font->glyphs[g]) + { + firstFont = font; + break; + } + } + if (i == nglyphs || !firstFont) + goto bail2; + glyph = firstFont->glyphs[g]; + format = firstFont->format; + x = glyphs[i].x + glyph->metrics.xOff; + y = glyphs[i].y + glyph->metrics.yOff; + prevPublic = NULL; + while (++i < nglyphs) + { + XftFont *pub = glyphs[i].font; + XftFontInt *font = (XftFontInt *) pub; + g = glyphs[i].glyph; + /* Substitute default for non-existant glyphs */ + if (g >= font->num_glyphs || !font->glyphs[g]) + g = 0; + /* + * check to see if the glyph is placed where it would + * fall using the normal spacing + */ + if ((glyph = font->glyphs[g])) + { + if (pub != prevPublic || x != glyphs[i].x || y != glyphs[i].y) + { + prevPublic = pub; + if (font->format != format) + format = XftPreferFormat (dpy, font->format, format); + x = glyphs[i].x; + y = glyphs[i].y; + ++nelt; + } + x += glyph->metrics.xOff; + y += glyph->metrics.yOff; + } + } + + elts = elts_local; + if (nelt > NUM_ELT_LOCAL) + { + elts = malloc (nelt * sizeof (XGlyphElt8)); + if (!elts) + goto bail2; + } + + /* + * Generate the list of glyph elts + */ + nelt = 0; + x = y = 0; + n = 0; + j = 0; + prevPublic = NULL; + for (i = 0; i < nglyphs; i++) + { + XftFont *pub = glyphs[i].font; + XftFontInt *font = (XftFontInt *) pub; + + g = glyphs[i].glyph; + /* Substitute default for non-existant glyphs */ + if (g >= font->num_glyphs || !font->glyphs[g]) + g = 0; + if ((glyph = font->glyphs[g])) + { + if (!i || pub != prevPublic || x != glyphs[i].x || y != glyphs[i].y) + { + if (n) + { + elts[nelt].nchars = n; + nelt++; + } + elts[nelt].glyphset = font->glyphset; + elts[nelt].chars = char8 + size * j; + elts[nelt].xOff = glyphs[i].x - x; + elts[nelt].yOff = glyphs[i].y - y; + prevPublic = pub; + x = glyphs[i].x; + y = glyphs[i].y; + n = 0; + } + switch (width) { + case 1: char8[j] = (char) g; break; + case 2: char16[j] = (unsigned short) g; break; + case 4: char32[j] = (unsigned int) g; break; + } + x += glyph->metrics.xOff; + y += glyph->metrics.yOff; + j++; + n++; + } + } + if (n) + { + elts[nelt].nchars = n; + nelt++; + } + switch (width) { + case 1: + XRenderCompositeText8 (dpy, op, src, dst, format, + srcx, srcy, glyphs[0].x, glyphs[0].y, + elts, nelt); + break; + case 2: + XRenderCompositeText16 (dpy, op, src, dst, format, + srcx, srcy, glyphs[0].x, glyphs[0].y, + (XGlyphElt16 *) elts, nelt); + break; + case 4: + XRenderCompositeText32 (dpy, op, src, dst, format, + srcx, srcy, glyphs[0].x, glyphs[0].y, + (XGlyphElt32 *) elts, nelt); + break; + } + + if (elts != elts_local) + free (elts); +bail2: + if (chars != char_local) + free (chars); +bail1: + if (glyphs_loaded) + for (i = 0; i < nglyphs; i++) + _XftFontManageMemory (dpy, glyphs[i].font); +} + +_X_EXPORT void +XftCharFontSpecRender (Display *dpy, + int op, + Picture src, + Picture dst, + int srcx, + int srcy, + _Xconst XftCharFontSpec *chars, + int len) +{ + XftGlyphFontSpec *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (XftGlyphFontSpec)); + if (!glyphs) + return; + } + for (i = 0; i < len; i++) + { + glyphs[i].font = chars[i].font; + glyphs[i].glyph = XftCharIndex(dpy, glyphs[i].font, chars[i].ucs4); + glyphs[i].x = chars[i].x; + glyphs[i].y = chars[i].y; + } + + XftGlyphFontSpecRender (dpy, op, src, dst, srcx, srcy, glyphs, len); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftTextRender8 (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar8 *string, + int len) +{ + FT_UInt *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (FT_UInt)); + if (!glyphs) + return; + } + for (i = 0; i < len; i++) + glyphs[i] = XftCharIndex (dpy, pub, string[i]); + XftGlyphRender (dpy, op, src, pub, dst, + srcx, srcy, x, y, glyphs, len); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftTextRender16 (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar16 *string, + int len) +{ + FT_UInt *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (FT_UInt)); + if (!glyphs) + return; + } + for (i = 0; i < len; i++) + glyphs[i] = XftCharIndex (dpy, pub, string[i]); + XftGlyphRender (dpy, op, src, pub, dst, + srcx, srcy, x, y, glyphs, len); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftTextRender16BE (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar8 *string, + int len) +{ + FT_UInt *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (FT_UInt)); + if (!glyphs) + return; + } + for (i = 0; i < len; i++) + glyphs[i] = XftCharIndex (dpy, pub, + (string[i*2]<<8) | string[i*2+1]); + XftGlyphRender (dpy, op, src, pub, dst, + srcx, srcy, x, y, glyphs, len); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftTextRender16LE (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar8 *string, + int len) +{ + FT_UInt *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (FT_UInt)); + if (!glyphs) + return; + } + for (i = 0; i < len; i++) + glyphs[i] = XftCharIndex (dpy, pub, + string[i*2] | (string[i*2+1]<<8)); + XftGlyphRender (dpy, op, src, pub, dst, + srcx, srcy, x, y, glyphs, len); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftTextRender32 (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar32 *string, + int len) +{ + FT_UInt *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (FT_UInt)); + if (!glyphs) + return; + } + for (i = 0; i < len; i++) + glyphs[i] = XftCharIndex (dpy, pub, string[i]); + XftGlyphRender (dpy, op, src, pub, dst, + srcx, srcy, x, y, glyphs, len); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftTextRender32BE (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar8 *string, + int len) +{ + FT_UInt *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (FT_UInt)); + if (!glyphs) + return; + } + for (i = 0; i < len; i++) + glyphs[i] = XftCharIndex (dpy, pub, + (string[i*4] << 24) | + (string[i*4+1] << 16) | + (string[i*4+2] << 8) | + (string[i*4+3])); + XftGlyphRender (dpy, op, src, pub, dst, + srcx, srcy, x, y, glyphs, len); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftTextRender32LE (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar8 *string, + int len) +{ + FT_UInt *glyphs, glyphs_local[NUM_LOCAL]; + int i; + + if (len <= NUM_LOCAL) + glyphs = glyphs_local; + else + { + glyphs = malloc (len * sizeof (FT_UInt)); + if (!glyphs) + return; + } + for (i = 0; i < len; i++) + glyphs[i] = XftCharIndex (dpy, pub, + (string[i*4]) | + (string[i*4+1] << 8) | + (string[i*4+2] << 16) | + (string[i*4+3] << 24)); + XftGlyphRender (dpy, op, src, pub, dst, + srcx, srcy, x, y, glyphs, len); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftTextRenderUtf8 (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar8 *string, + int len) +{ + FT_UInt *glyphs, *glyphs_new, glyphs_local[NUM_LOCAL]; + FcChar32 ucs4; + int i; + int l; + int size; + + i = 0; + glyphs = glyphs_local; + size = NUM_LOCAL; + while (len && (l = FcUtf8ToUcs4 (string, &ucs4, len)) > 0) + { + if (i == size) + { + glyphs_new = malloc (size * 2 * sizeof (FT_UInt)); + if (!glyphs_new) + { + if (glyphs != glyphs_local) + free (glyphs); + return; + } + memcpy (glyphs_new, glyphs, size * sizeof (FT_UInt)); + size *= 2; + if (glyphs != glyphs_local) + free (glyphs); + glyphs = glyphs_new; + } + glyphs[i++] = XftCharIndex (dpy, pub, ucs4); + string += l; + len -= l; + } + XftGlyphRender (dpy, op, src, pub, dst, + srcx, srcy, x, y, glyphs, i); + if (glyphs != glyphs_local) + free (glyphs); +} + +_X_EXPORT void +XftTextRenderUtf16 (Display *dpy, + int op, + Picture src, + XftFont *pub, + Picture dst, + int srcx, + int srcy, + int x, + int y, + _Xconst FcChar8 *string, + FcEndian endian, + int len) +{ + FT_UInt *glyphs, *glyphs_new, glyphs_local[NUM_LOCAL]; + FcChar32 ucs4; + int i; + int l; + int size; + + i = 0; + glyphs = glyphs_local; + size = NUM_LOCAL; + while (len && (l = FcUtf16ToUcs4 (string, endian, &ucs4, len)) > 0) + { + if (i == size) + { + glyphs_new = malloc (size * 2 * sizeof (FT_UInt)); + if (!glyphs_new) + { + if (glyphs != glyphs_local) + free (glyphs); + return; + } + memcpy (glyphs_new, glyphs, size * sizeof (FT_UInt)); + size *= 2; + if (glyphs != glyphs_local) + free (glyphs); + glyphs = glyphs_new; + } + glyphs[i++] = XftCharIndex (dpy, pub, ucs4); + string += l; + len -= l; + } + XftGlyphRender (dpy, PictOpOver, src, pub, dst, + srcx, srcy, x, y, glyphs, i); + if (glyphs != glyphs_local) + free (glyphs); +} diff --git a/libXft/src/xftstr.c b/libXft/src/xftstr.c new file mode 100644 index 000000000..a5733f4bb --- /dev/null +++ b/libXft/src/xftstr.c @@ -0,0 +1,35 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +_X_HIDDEN int +_XftMatchSymbolic (XftSymbolic *s, int n, const char *name, int def) +{ + while (n--) + { + if (!FcStrCmpIgnoreCase ((FcChar8 *) s->name, (FcChar8 *) name)) + return s->value; + s++; + } + return def; +} diff --git a/libXft/src/xftswap.c b/libXft/src/xftswap.c new file mode 100644 index 000000000..942efdb31 --- /dev/null +++ b/libXft/src/xftswap.c @@ -0,0 +1,119 @@ +/* + * Copyright © 2002 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +_X_HIDDEN int +XftNativeByteOrder (void) +{ + int whichbyte = 1; + + if (*((char *) &whichbyte)) + return LSBFirst; + return MSBFirst; +} + +/* byte swap a 32-bit value */ +#define swapl(x, n) { \ + n = ((char *) (x))[0];\ + ((char *) (x))[0] = ((char *) (x))[3];\ + ((char *) (x))[3] = n;\ + n = ((char *) (x))[1];\ + ((char *) (x))[1] = ((char *) (x))[2];\ + ((char *) (x))[2] = n; } + +/* byte swap a short */ +#define swaps(x, n) { \ + n = ((char *) (x))[0];\ + ((char *) (x))[0] = ((char *) (x))[1];\ + ((char *) (x))[1] = n; } + +/* byte swap a three-byte unit */ +#define swapt(x, n) { \ + n = ((char *) (x))[0];\ + ((char *) (x))[0] = ((char *) (x))[2];\ + ((char *) (x))[2] = n; } + +_X_HIDDEN void +XftSwapCARD32 (CARD32 *data, int u) +{ + char n; + while (u--) + { + swapl (data, n); + data++; + } +} + +_X_HIDDEN void +XftSwapCARD24 (CARD8 *data, int width, int height) +{ + int units, u; + char n; + CARD8 *d; + + units = width / 3; + while (height--) + { + d = data; + data += width; + u = units; + while (u--) + { + swapt (d, n); + d += 3; + } + } +} + +_X_HIDDEN void +XftSwapCARD16 (CARD16 *data, int u) +{ + char n; + while (u--) + { + swaps (data, n); + data++; + } +} + +_X_HIDDEN void +XftSwapImage (XImage *image) +{ + switch (image->bits_per_pixel) { + case 32: + XftSwapCARD32 ((CARD32 *) image->data, + image->height * image->bytes_per_line >> 2); + break; + case 24: + XftSwapCARD24 ((CARD8 *) image->data, + image->bytes_per_line, + image->height); + break; + case 16: + XftSwapCARD16 ((CARD16 *) image->data, + image->height * image->bytes_per_line >> 1); + break; + default: + break; + } +} diff --git a/libXft/src/xftxlfd.c b/libXft/src/xftxlfd.c new file mode 100644 index 000000000..7c1991163 --- /dev/null +++ b/libXft/src/xftxlfd.c @@ -0,0 +1,177 @@ +/* + * Copyright © 2000 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "xftint.h" + +static XftSymbolic XftXlfdWeights[] = { + { "light", FC_WEIGHT_LIGHT }, + { "medium", FC_WEIGHT_MEDIUM }, + { "regular", FC_WEIGHT_MEDIUM }, + { "demibold", FC_WEIGHT_DEMIBOLD }, + { "bold", FC_WEIGHT_BOLD }, + { "black", FC_WEIGHT_BLACK }, +}; + +#define NUM_XLFD_WEIGHTS (sizeof XftXlfdWeights/sizeof XftXlfdWeights[0]) + +static XftSymbolic XftXlfdSlants[] = { + { "r", FC_SLANT_ROMAN }, + { "i", FC_SLANT_ITALIC }, + { "o", FC_SLANT_OBLIQUE }, +}; + +#define NUM_XLFD_SLANTS (sizeof XftXlfdSlants/sizeof XftXlfdSlants[0]) + +/* + * Cut out one XLFD field, placing it in 'save' and return + * the start of 'save' + */ +static char * +XftSplitStr (const char *field, char *save) +{ + char *s = save; + char c; + + while (*field) + { + if (*field == '-') + break; + c = *field++; + *save++ = c; + } + *save = 0; + return s; +} + +/* + * convert one XLFD numeric field. Return -1 if the field is '*' + */ + +static const char * +XftGetInt(const char *ptr, int *val) +{ + if (*ptr == '*') { + *val = -1; + ptr++; + } else + for (*val = 0; *ptr >= '0' && *ptr <= '9';) + *val = *val * 10 + *ptr++ - '0'; + if (*ptr == '-') + return ptr; + return (char *) 0; +} + +_X_EXPORT FcPattern * +XftXlfdParse (const char *xlfd_orig, FcBool ignore_scalable, FcBool complete) +{ + FcPattern *pat; + const char *xlfd = xlfd_orig; + const char *foundry; + const char *family; + const char *weight_name; + const char *slant; + const char *registry; + const char *encoding; + char *save; + int pixel; + int point; + int resx; + int resy; + int slant_value, weight_value; + double dpixel; + + if (*xlfd != '-') + return NULL; + if (!(xlfd = strchr (foundry = ++xlfd, '-'))) return NULL; + if (!(xlfd = strchr (family = ++xlfd, '-'))) return NULL; + if (!(xlfd = strchr (weight_name = ++xlfd, '-'))) return NULL; + if (!(xlfd = strchr (slant = ++xlfd, '-'))) return NULL; + if (!(xlfd = strchr (/* setwidth_name = */ ++xlfd, '-'))) return NULL; + if (!(xlfd = strchr (/* add_style_name = */ ++xlfd, '-'))) return NULL; + if (!(xlfd = XftGetInt (++xlfd, &pixel))) return NULL; + if (!(xlfd = XftGetInt (++xlfd, &point))) return NULL; + if (!(xlfd = XftGetInt (++xlfd, &resx))) return NULL; + if (!(xlfd = XftGetInt (++xlfd, &resy))) return NULL; + if (!(xlfd = strchr (/* spacing = */ ++xlfd, '-'))) return NULL; + if (!(xlfd = strchr (/* average_width = */ ++xlfd, '-'))) return NULL; + if (!(xlfd = strchr (registry = ++xlfd, '-'))) return NULL; + /* make sure no fields follow this one */ + if ((xlfd = strchr (encoding = ++xlfd, '-'))) return NULL; + + if (!pixel) + return NULL; + + pat = FcPatternCreate (); + if (!pat) + return NULL; + + save = (char *) malloc (strlen (foundry) + 1); + + if (!save) { + FcPatternDestroy (pat); + return NULL; + } + + if (!FcPatternAddString (pat, XFT_XLFD, (FcChar8 *) xlfd_orig)) goto bail; + + XftSplitStr (foundry, save); + if (save[0] && strcmp (save, "*") != 0) + if (!FcPatternAddString (pat, FC_FOUNDRY, (FcChar8 *) save)) goto bail; + + XftSplitStr (family, save); + if (save[0] && strcmp (save, "*") != 0) + if (!FcPatternAddString (pat, FC_FAMILY, (FcChar8 *) save)) goto bail; + + weight_value = _XftMatchSymbolic (XftXlfdWeights, NUM_XLFD_WEIGHTS, + XftSplitStr (weight_name, save), + FC_WEIGHT_MEDIUM); + if (!FcPatternAddInteger (pat, FC_WEIGHT, weight_value)) + goto bail; + + slant_value = _XftMatchSymbolic (XftXlfdSlants, NUM_XLFD_SLANTS, + XftSplitStr (slant, save), + FC_SLANT_ROMAN); + if (!FcPatternAddInteger (pat, FC_SLANT, slant_value)) + goto bail; + + dpixel = (double) pixel; + + if (point > 0) + { + if (!FcPatternAddDouble (pat, FC_SIZE, ((double) point) / 10.0)) goto bail; + if (pixel <= 0 && resy > 0) + { + dpixel = (double) point * (double) resy / 720.0; + } + } + + if (dpixel > 0) + if (!FcPatternAddDouble (pat, FC_PIXEL_SIZE, dpixel)) goto bail; + + free (save); + return pat; + +bail: + free (save); + FcPatternDestroy (pat); + return NULL; +} diff --git a/libXft/xft.pc.in b/libXft/xft.pc.in new file mode 100644 index 000000000..68d108990 --- /dev/null +++ b/libXft/xft.pc.in @@ -0,0 +1,12 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: Xft +Description: X FreeType library +Version: @VERSION@ +Requires: xproto +Requires.private: xrender, fontconfig, freetype2 +Cflags: -I${includedir} +Libs: -L${libdir} -lXft |