From 52a3d6a04aa1a18223059334f8d5ed2955461b7d Mon Sep 17 00:00:00 2001 From: Kaleb Keithley Date: Fri, 14 Nov 2003 16:48:48 +0000 Subject: Initial revision --- include/X11/Xft/Xft.h | 632 ++++++++++++++++++++ include/X11/Xft/XftCompat.h | 167 ++++++ src/xftcolor.c | 125 ++++ src/xftcore.c | 1377 +++++++++++++++++++++++++++++++++++++++++++ src/xftdbg.c | 50 ++ src/xftdpy.c | 529 +++++++++++++++++ src/xftdraw.c | 993 +++++++++++++++++++++++++++++++ src/xftextent.c | 291 +++++++++ src/xftfont.c | 210 +++++++ src/xftfreetype.c | 1048 ++++++++++++++++++++++++++++++++ src/xftglyphs.c | 812 +++++++++++++++++++++++++ src/xftinit.c | 118 ++++ src/xftint.h | 426 +++++++++++++ src/xftlist.c | 61 ++ src/xftname.c | 69 +++ src/xftrender.c | 981 ++++++++++++++++++++++++++++++ src/xftstr.c | 40 ++ src/xftswap.c | 122 ++++ src/xftxlfd.c | 180 ++++++ xft-config.in | 100 ++++ xft.pc.in | 15 + 21 files changed, 8346 insertions(+) create mode 100644 include/X11/Xft/Xft.h create mode 100644 include/X11/Xft/XftCompat.h create mode 100644 src/xftcolor.c create mode 100644 src/xftcore.c create mode 100644 src/xftdbg.c create mode 100644 src/xftdpy.c create mode 100644 src/xftdraw.c create mode 100644 src/xftextent.c create mode 100644 src/xftfont.c create mode 100644 src/xftfreetype.c create mode 100644 src/xftglyphs.c create mode 100644 src/xftinit.c create mode 100644 src/xftint.h create mode 100644 src/xftlist.c create mode 100644 src/xftname.c create mode 100644 src/xftrender.c create mode 100644 src/xftstr.c create mode 100644 src/xftswap.c create mode 100644 src/xftxlfd.c create mode 100644 xft-config.in create mode 100644 xft.pc.in diff --git a/include/X11/Xft/Xft.h b/include/X11/Xft/Xft.h new file mode 100644 index 0000000..edba002 --- /dev/null +++ b/include/X11/Xft/Xft.h @@ -0,0 +1,632 @@ +/* + * $XFree86: xc/lib/Xft/Xft.h,v 1.32 2003/02/25 21:57:53 dawes Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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_ + +#define XFT_MAJOR 2 +#define XFT_MINOR 1 +#define XFT_REVISION 0 +#define XFT_VERSION ((XFT_MAJOR * 10000) + (XFT_MINOR * 100) + (XFT_REVISION)) +#define XftVersion XFT_VERSION + +#include +#include +#include +#include + +#include +/* #include */ + +#ifndef _XFT_NO_COMPAT_ +#include +#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); + + +/* xftcore.c */ + +/* xftdir.c */ +FcBool +XftDirScan (FcFontSet *set, _Xconst char *dir, FcBool force); + +FcBool +XftDirSave (FcFontSet *set, _Xconst char *dir); + +/* 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, ...); + +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); + +/* xftgram.y */ + +/* xftinit.c */ +FcBool +XftInit (_Xconst char *config); + +int +XftGetVersion (void); + +/* xftlex.l */ + +/* xftlist.c */ + +FcFontSet * +XftListFonts (Display *dpy, + int screen, + ...); + +/* xftmatch.c */ + +/* xftmatrix.c */ + +/* xftname.c */ +FcPattern +*XftNameParse (_Xconst char *name); + +/* xftpat.c */ + +/* 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); + +/* xftstr.c */ + +/* xftxlfd.c */ +FcPattern * +XftXlfdParse (_Xconst char *xlfd_orig, Bool ignore_scalable, Bool complete); + +_XFUNCPROTOEND + +#endif /* _XFT_H_ */ diff --git a/include/X11/Xft/XftCompat.h b/include/X11/Xft/XftCompat.h new file mode 100644 index 0000000..9ddfc59 --- /dev/null +++ b/include/X11/Xft/XftCompat.h @@ -0,0 +1,167 @@ +/* + * $XFree86: xc/lib/Xft/XftCompat.h,v 1.5 2002/10/02 07:02:32 keithp Exp $ + * + * Copyright © 2001 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 + +/* + * 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 XftListFontsPatternObjects FcListFontsPatternObjects + +#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/src/xftcolor.c b/src/xftcolor.c new file mode 100644 index 0000000..7a5005d --- /dev/null +++ b/src/xftcolor.c @@ -0,0 +1,125 @@ +/* + * $XFree86: xc/lib/Xft/xftcolor.c,v 1.3 2002/10/11 17:53:02 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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" + +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); +} + +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; +} + +void +XftColorFree (Display *dpy, + Visual *visual, + Colormap cmap, + XftColor *color) +{ + if (visual->class != TrueColor) + XFreeColors (dpy, cmap, &color->pixel, 1, 0); +} diff --git a/src/xftcore.c b/src/xftcore.c new file mode 100644 index 0000000..5c0009d --- /dev/null +++ b/src/xftcore.c @@ -0,0 +1,1377 @@ +/* + * $XFree86: xc/lib/Xft/xftcore.c,v 1.13 2003/02/15 22:30:51 dawes Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 +#include "xftint.h" +#include + +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, FcTrue, missing, nmissing); + return font->glyphs[0]; +} + +static int XftGetImageErrorHandler (Display *dpy, XErrorEvent *error_event) +{ + return 0; +} + +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 = 0; + } + 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 + +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 = 0; + } + 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); +} + +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 = 0; + } + 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/src/xftdbg.c b/src/xftdbg.c new file mode 100644 index 0000000..4f5a6cf --- /dev/null +++ b/src/xftdbg.c @@ -0,0 +1,50 @@ +/* + * $XFree86: xc/lib/Xft/xftdbg.c,v 1.4 2002/02/15 07:36:10 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 +#include +#include "xftint.h" + +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/src/xftdpy.c b/src/xftdpy.c new file mode 100644 index 0000000..09f5f0e --- /dev/null +++ b/src/xftdpy.c @@ -0,0 +1,529 @@ +/* + * $XFree86: xc/lib/Xft/xftdpy.c,v 1.20 2002/10/11 17:53:02 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 +#include +#include +#include +#include "xftint.h" + +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; +} + + +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 0; + + 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 = 0; + info->hasRender = (XRenderQueryExtension (dpy, &event_base, &error_base) && + (XRenderFindVisualFormat (dpy, DefaultVisual (dpy, DefaultScreen (dpy))) != 0)); + 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 = 0; + + info->next = _XftDisplayInfo; + _XftDisplayInfo = info; + + info->glyph_memory = 0; + 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 0; +} + +/* + * 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); +} + +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); +} + +Bool +XftDefaultHasRender (Display *dpy) +{ + XftDisplayInfo *info = _XftDisplayInfoGet (dpy, True); + + if (!info) + return False; + return info->hasRender; +} + +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; +} + +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; + if (!_XftDefaultInitBool (dpy, pat, FC_AUTOHINT)) + goto bail1; + 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 0; +} + +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; +} + +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; +} + +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; +} + +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; +} + +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)); + } + if (FcPatternGet (pattern, FC_HINTING, 0, &v) == FcResultNoMatch) + { + FcPatternAddBool (pattern, FC_HINTING, + XftDefaultGetBool (dpy, FC_HINTING, screen, + True)); + } + 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 + 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/src/xftdraw.c b/src/xftdraw.c new file mode 100644 index 0000000..d70266c --- /dev/null +++ b/src/xftdraw.c @@ -0,0 +1,993 @@ +/* + * $XFree86: xc/lib/Xft/xftdraw.c,v 1.25 2002/10/11 17:53:02 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 +#include +#include +#include "xftint.h" +#include +#include + +/* + * 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; +} + +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; +} + +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; +} + +XftDraw * +XftDrawCreate (Display *dpy, + Drawable drawable, + Visual *visual, + Colormap colormap) +{ + XftDraw *draw; + + draw = (XftDraw *) malloc (sizeof (XftDraw)); + if (!draw) + return 0; + + 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 = 0; + draw->core.use_pixmap = 0; + draw->clip_type = XftClipTypeNone; + draw->subwindow_mode = ClipByChildren; + XftMemAlloc (XFT_MEM_DRAW, sizeof (XftDraw)); + return draw; +} + +XftDraw * +XftDrawCreateBitmap (Display *dpy, + Pixmap bitmap) +{ + XftDraw *draw; + + draw = (XftDraw *) malloc (sizeof (XftDraw)); + if (!draw) + return 0; + draw->dpy = dpy; + draw->drawable = (Drawable) bitmap; + draw->screen = _XftDrawScreen (dpy, bitmap, 0); + draw->depth = 1; + draw->bits_per_pixel = 1; + draw->visual = 0; + draw->colormap = 0; + draw->render.pict = 0; + draw->core.gc = 0; + draw->clip_type = XftClipTypeNone; + draw->subwindow_mode = ClipByChildren; + XftMemAlloc (XFT_MEM_DRAW, sizeof (XftDraw)); + return draw; +} + +XftDraw * +XftDrawCreateAlpha (Display *dpy, + Pixmap pixmap, + int depth) +{ + XftDraw *draw; + + draw = (XftDraw *) malloc (sizeof (XftDraw)); + if (!draw) + return 0; + draw->dpy = dpy; + draw->drawable = (Drawable) pixmap; + draw->screen = _XftDrawScreen (dpy, pixmap, 0); + draw->depth = depth; + draw->bits_per_pixel = 0; /* don't find out until we need it */ + draw->visual = 0; + draw->colormap = 0; + draw->render.pict = 0; + draw->core.gc = 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->hasRender) + return 0; + + if (draw->visual == 0) + { + 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); +} + +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 = 0; + } +} + +Display * +XftDrawDisplay (XftDraw *draw) +{ + return draw->dpy; +} + +Drawable +XftDrawDrawable (XftDraw *draw) +{ + return draw->drawable; +} + +Colormap +XftDrawColormap (XftDraw *draw) +{ + return draw->colormap; +} + +Visual * +XftDrawVisual (XftDraw *draw) +{ + return draw->visual; +} + +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); +} + +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; +} + +Picture +XftDrawPicture (XftDraw *draw) +{ + if (!_XftDrawRenderPrepare (draw)) + return 0; + return draw->render.pict; +} + +#define NUM_LOCAL 1024 + +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); + } +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); + } +} + +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, i - start); + } + } + else + { + while (i < len && !((XftFontInt *) glyphs[i].font)->format) + i++; + if (_XftDrawCorePrepare (draw, color)) + XftGlyphFontSpecCore (draw, color, glyphs, len); + } + } +} + +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); +} + +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); +} + +void +XftDrawRect (XftDraw *draw, + _Xconst XftColor *color, + int x, + int y, + unsigned int width, + unsigned int height) +{ + if (_XftDrawRenderPrepare (draw)) + { + XRenderFillRectangle (draw->dpy, PictOpOver, draw->render.pict, + &color->color, x, y, width, height); + } + else if (_XftDrawCorePrepare (draw, color)) + { + XftRectCore (draw, color, x, y, width, height); + } +} + +Bool +XftDrawSetClip (XftDraw *draw, + Region r) +{ + Region n = 0; + + /* + * 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; +} + +Bool +XftDrawSetClipRectangles (XftDraw *draw, + int xOrigin, + int yOrigin, + _Xconst XRectangle *rects, + int n) +{ + XftClipRect *new = 0; + + /* + * Check for quick exit + */ + if (draw->clip_type == XftClipTypeRectangles && + !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; +} + +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/src/xftextent.c b/src/xftextent.c new file mode 100644 index 0000000..d8e91e5 --- /dev/null +++ b/src/xftextent.c @@ -0,0 +1,291 @@ +/* + * $XFree86: xc/lib/Xft/xftextent.c,v 1.10 2002/12/14 01:59:38 dawes Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 +#include +#include "xftint.h" + +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 = 0; + while (n) + { + glyph = *g++; + n--; + if (glyph < font->num_glyphs && + (xftg = font->glyphs[glyph])) + break; + } + if (n == 0 && !xftg) + { + extents->width = 0; + extents->height = 0; + extents->x = 0; + extents->y = 0; + extents->yOff = 0; + extents->xOff = 0; + } + 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 + +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); +} + +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); +} + +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); +} + +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); +} + +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/src/xftfont.c b/src/xftfont.c new file mode 100644 index 0000000..7698d60 --- /dev/null +++ b/src/xftfont.c @@ -0,0 +1,210 @@ +/* + * $XFree86: xc/lib/Xft/xftfont.c,v 1.11 2002/10/11 17:53:02 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 +#include +#include "xftint.h" + +FcPattern * +XftFontMatch (Display *dpy, + int screen, + _Xconst FcPattern *pattern, + FcResult *result) +{ + FcPattern *new; + FcPattern *match; + + if (!XftInit (0)) + return 0; + + new = FcPatternDuplicate (pattern); + if (!new) + return 0; + + if (XftDebug () & XFT_DBG_OPENV) + { + printf ("XftFontMatch pattern "); + FcPatternPrint (new); + } + FcConfigSubstitute (0, 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 (0, new, result); + if (XftDebug () & XFT_DBG_OPENV) + { + printf ("XftFontMatch result "); + FcPatternPrint (match); + } + FcPatternDestroy (new); + return match; +} + +XftFont * +XftFontOpen (Display *dpy, int screen, ...) +{ + va_list va; + FcPattern *pat; + FcPattern *match; + FcResult result; + XftFont *font; + + va_start (va, screen); + pat = FcPatternVaBuild (0, va); + va_end (va); + if (!pat) + { + if (XftDebug () & XFT_DBG_OPEN) + printf ("XftFontOpen: Invalid pattern argument\n"); + return 0; + } + 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 0; + + font = XftFontOpenPattern (dpy, match); + if (!font) + { + if (XftDebug () & XFT_DBG_OPEN) + printf ("No Font\n"); + FcPatternDestroy (match); + } + + return font; +} + +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 0; + 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 0; + + font = XftFontOpenPattern (dpy, match); + if (!font) + { + if (XftDebug () & XFT_DBG_OPEN) + printf ("No Font\n"); + FcPatternDestroy (match); + } + + return font; +} + +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 0; + 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 0; + + font = XftFontOpenPattern (dpy, match); + if (!font) + { + if (XftDebug () & XFT_DBG_OPEN) + printf ("No Font\n"); + FcPatternDestroy (match); + } + + return font; +} + diff --git a/src/xftfreetype.c b/src/xftfreetype.c new file mode 100644 index 0000000..1d3a473 --- /dev/null +++ b/src/xftfreetype.c @@ -0,0 +1,1048 @@ +/* + * $XFree86: xc/lib/Xft/xftfreetype.c,v 1.29 2002/10/11 17:53:02 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 +#include +#include +#include "xftint.h" +#include + +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; +int XftMaxFreeTypeFiles = 5; + +static XftFtFile * +_XftGetFile (const FcChar8 *file, int id) +{ + XftFtFile *f; + + if (!XftInitFtLibrary ()) + return 0; + + for (f = _XftFtFiles; f; f = f->next) + { + if (!strcmp (f->file, (void *) 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 0; + + 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, (void *) file); + f->id = id; + + f->lock = 0; + f->face = 0; + f->xsize = 0; + f->ysize = 0; + return f; +} + +static XftFtFile * +_XftGetFaceFile (FT_Face face) +{ + XftFtFile *f; + + f = malloc (sizeof (XftFtFile)); + if (!f) + return 0; + XftMemAlloc (XFT_MEM_FILE, sizeof(XftFtFile)); + f->next = 0; + + f->ref = 1; + + f->file = 0; + f->id = 0; + f->lock = 0; + f->face = face; + f->xsize = 0; + f->ysize = 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 = 0; + } + } +} + +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"); +} + +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); + 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, 0); + 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) + strlen (f->file) + 1); + 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; +} + +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 = 0; + } + return face; +} + +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; + FcChar32 hash, *hashp; + FT_Face face; + int nhash; + + if (!info) + return FcFalse; + + /* + * Find the associated file + */ + switch (FcPatternGetString (pattern, FC_FILE, 0, &filename)) { + case FcResultNoMatch: + filename = 0; + 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); + else + fi->file = 0; + 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 *) ""), 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; + + /* disable bitmaps when anti-aliasing or transforming glyphs */ + if (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; + } + + if (!hinting) + fi->load_flags |= FT_LOAD_NO_HINTING; + + /* 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 = 0; +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 0; + + if (!XftFontInfoFill (dpy, pattern, fi)) + { + free (fi); + fi = 0; + } + XftMemAlloc (XFT_MEM_FONT, sizeof (XftFontInfo)); + return fi; +} + +void +XftFontInfoDestroy (Display *dpy, XftFontInfo *fi) +{ + XftFontInfoEmpty (dpy, fi); + XftMemFree (XFT_MEM_FONT, sizeof (XftFontInfo)); + free (fi); +} + +FcChar32 +XftFontInfoHash (_Xconst XftFontInfo *fi) +{ + return fi->hash; +} + +FcBool +XftFontInfoEqual (_Xconst XftFontInfo *a, _Xconst XftFontInfo *b) +{ + return memcmp ((void *) a, (void *) b, sizeof (XftFontInfo)) == 0; +} + +XftFont * +XftFontOpenInfo (Display *dpy, + FcPattern *pattern, + XftFontInfo *fi) +{ + XftDisplayInfo *info = _XftDisplayInfoGet (dpy, True); + FT_Face face; + XftFont **bucket; + XftFontInt *font; + XRenderPictFormat pf, *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; + + if (!info) + return 0; + /* + * 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 = FcFreeTypeCharSet (face, FcConfigGetBlanks (0)); + + 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: + pf.depth = 32; + pf.type = PictTypeDirect; + pf.direct.alpha = 24; + pf.direct.alphaMask = 0xff; + pf.direct.red = 16; + pf.direct.redMask = 0xff; + pf.direct.green = 8; + pf.direct.greenMask = 0xff; + pf.direct.blue = 0; + pf.direct.blueMask = 0xff; + format = XRenderFindFormat(dpy, + PictFormatType| + PictFormatDepth| + PictFormatAlpha| + PictFormatAlphaMask| + PictFormatRed| + PictFormatRedMask| + PictFormatGreen| + PictFormatGreenMask| + PictFormatBlue| + PictFormatBlueMask, + &pf, 0); + break; + default: + pf.depth = 8; + pf.type = PictTypeDirect; + pf.direct.alpha = 0; + pf.direct.alphaMask = 0xff; + format = XRenderFindFormat(dpy, + PictFormatType| + PictFormatDepth| + PictFormatAlpha| + PictFormatAlphaMask, + &pf, 0); + break; + } + } + else + { + pf.depth = 1; + pf.type = PictTypeDirect; + pf.direct.alpha = 0; + pf.direct.alphaMask = 0x1; + format = XRenderFindFormat(dpy, + PictFormatType| + PictFormatDepth| + PictFormatAlpha| + PictFormatAlphaMask, + &pf, 0); + } + + if (!format) + goto bail0; + } + else + format = 0; + + 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; + } + + alloc_size = (sizeof (XftFontInt) + + face->num_glyphs * sizeof (XftGlyph *) + + hash_value * sizeof (XftUcsHash)); + font = malloc (alloc_size); + + if (!font) + goto bail1; + + 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', face->num_glyphs * sizeof (XftGlyph *)); + font->num_glyphs = face->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; + +bail1: + _XftUnlockFile (fi->file); +bail0: + return 0; +} + +XftFont * +XftFontOpenPattern (Display *dpy, FcPattern *pattern) +{ + XftFontInfo info; + XftFont *font; + + if (!XftFontInfoFill (dpy, pattern, &info)) + return 0; + + font = XftFontOpenInfo (dpy, pattern, &info); + XftFontInfoEmpty (dpy, &info); + return font; +} + +XftFont * +XftFontCopy (Display *dpy, XftFont *public) +{ + XftFontInt *font = (XftFontInt *) public; + + font->ref++; + return public; +} + +static void +XftFontDestroy (Display *dpy, XftFont *public) +{ + XftFontInt *font = (XftFontInt *) public; + int i; + + /* 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); + } + } + + /* 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; +} + +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; + } +} + +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); + } +} + +FcBool +XftInitFtLibrary (void) +{ + if (_XftFTlibrary) + return FcTrue; + if (FT_Init_FreeType (&_XftFTlibrary)) + return FcFalse; + return FcTrue; +} diff --git a/src/xftglyphs.c b/src/xftglyphs.c new file mode 100644 index 0000000..85521f0 --- /dev/null +++ b/src/xftglyphs.c @@ -0,0 +1,812 @@ +/* + * $XFree86: xc/lib/Xft/xftglyphs.c,v 1.23 2002/10/11 17:53:02 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 +#include +#include +#include "xftint.h" +#include +#include + +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); +} + +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; + + /* + * 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 ); + + /* + * Try to keep monospace fonts ink-inside + * XXX transformed? + */ + if (font->info.spacing != FC_PROPORTIONAL && !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_PROPORTIONAL) + { + 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 + { + xftg->bitmap = malloc (sizergba); + if (xftg->bitmap) + memcpy (xftg->bitmap, bufBitmapRgba, sizergba); + } + } + 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 + { + xftg->bitmap = malloc (size); + if (xftg->bitmap) + memcpy (xftg->bitmap, bufBitmap, size); + } + } + 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); +} + +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] = 0; + } + if (font->glyphset && nused) + XRenderFreeGlyphs (dpy, font->glyphset, glyphBuf, nused); +} + +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 = 0; + 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; +} + +FcBool +XftCharExists (Display *dpy, + XftFont *pub, + FcChar32 ucs4) +{ + if (pub->charset) + return FcCharSetHasChar (pub->charset, ucs4); + return FcFalse; +} + +#define Missing ((FT_UInt) ~0) + +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 + */ +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); +} + +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/src/xftinit.c b/src/xftinit.c new file mode 100644 index 0000000..b858503 --- /dev/null +++ b/src/xftinit.c @@ -0,0 +1,118 @@ +/* + * $XFree86: xc/lib/Xft/xftinit.c,v 1.5 2002/10/11 17:53:02 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 +#include +#include "xftint.h" +#include + +Bool _XftConfigInitialized; + +Bool +XftInit (_Xconst char *config) +{ + if (_XftConfigInitialized) + return True; + _XftConfigInitialized = True; + if (!FcInit ()) + return False; + _XftNameInit (); + return True; +} + +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; + +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; +} + +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 (); + } +} + +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/src/xftint.h b/src/xftint.h new file mode 100644 index 0000000..f867cec --- /dev/null +++ b/src/xftint.h @@ -0,0 +1,426 @@ +/* + * $XFree86: xc/lib/Xft/xftint.h,v 1.37 2002/10/11 17:53:02 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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@xfree86.org + */ + +#ifndef _XFTINT_H_ +#define _XFTINT_H_ + +#include +#include +#define _XFT_NO_COMPAT_ +#include "Xft.h" +#include +#include + +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 */ + 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/src/xftlist.c b/src/xftlist.c new file mode 100644 index 0000000..3ec9380 --- /dev/null +++ b/src/xftlist.c @@ -0,0 +1,61 @@ +/* + * $XFree86: xc/lib/Xft/xftlist.c,v 1.3 2002/02/15 07:36:11 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 +#include "xftint.h" + +FcFontSet * +XftListFontsPatternObjects (Display *dpy, + int screen, + FcPattern *pattern, + FcObjectSet *os) +{ + return FcFontList (0, pattern, os); +} + +FcFontSet * +XftListFonts (Display *dpy, + int screen, + ...) +{ + va_list va; + FcFontSet *fs; + FcObjectSet *os; + FcPattern *pattern; + const char *first; + + va_start (va, screen); + + FcPatternVapBuild (pattern, 0, 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/src/xftname.c b/src/xftname.c new file mode 100644 index 0000000..ae0ab2e --- /dev/null +++ b/src/xftname.c @@ -0,0 +1,69 @@ +/* + * $XFree86: xc/lib/Xft/xftname.c,v 1.12 2002/05/24 07:02:38 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 + +static const FcObjectType _XftObjectTypes[] = { + { XFT_CORE, FcTypeBool, }, + { XFT_XLFD, FcTypeString, }, + { XFT_RENDER, FcTypeBool, }, +}; + +#define NUM_OBJECT_TYPES (sizeof _XftObjectTypes / sizeof _XftObjectTypes[0]) + +Bool _XftNameInitialized; + +void +_XftNameInit (void) +{ + if (_XftNameInitialized) + return; + FcNameRegisterObjectTypes (_XftObjectTypes, NUM_OBJECT_TYPES); +} + +FcPattern +*XftNameParse (const char *name) +{ + _XftNameInit (); + return FcNameParse ((FcChar8 *) name); +} + +FcBool +XftNameUnparse (FcPattern *pat, char *dest, int len) +{ + FcChar8 *name; + + name = FcNameUnparse (pat); + if (!name) + return FcFalse; + if (strlen ((char *) name) + 1 > len) + { + free (name); + return FcFalse; + } + strcpy (dest, ((char *) name)); + free (name); + return FcTrue; +} diff --git a/src/xftrender.c b/src/xftrender.c new file mode 100644 index 0000000..1836a14 --- /dev/null +++ b/src/xftrender.c @@ -0,0 +1,981 @@ +/* + * $XFree86: xc/lib/Xft/xftrender.c,v 1.15 2002/12/14 01:59:38 dawes Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 +#include "xftint.h" + +#define NUM_LOCAL 1024 +#define NUM_ELT_LOCAL 128 + +/* + * Use the Render extension to draw the glyphs + */ + +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); +} + +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); +} + +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); +} + +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; + 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 = 0; + 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) + goto bail2; + glyph = firstFont->glyphs[g]; + x = glyphs[i].x + glyph->metrics.xOff; + y = glyphs[i].y + glyph->metrics.yOff; + prevPublic = 0; + 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; + 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 = 0; + 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, firstFont->format, + srcx, srcy, glyphs[0].x, glyphs[0].y, + elts, nelt); + break; + case 2: + XRenderCompositeText16 (dpy, op, src, dst, firstFont->format, + srcx, srcy, glyphs[0].x, glyphs[0].y, + (XGlyphElt16 *) elts, nelt); + break; + case 4: + XRenderCompositeText32 (dpy, op, src, dst, firstFont->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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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); +} + +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/src/xftstr.c b/src/xftstr.c new file mode 100644 index 0000000..473ffad --- /dev/null +++ b/src/xftstr.c @@ -0,0 +1,40 @@ +/* + * $XFree86: xc/lib/Xft/xftstr.c,v 1.7 2002/02/15 07:36:11 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 +#include +#include +#include "xftint.h" + +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/src/xftswap.c b/src/xftswap.c new file mode 100644 index 0000000..d9c5313 --- /dev/null +++ b/src/xftswap.c @@ -0,0 +1,122 @@ +/* + * $XFree86: xc/lib/Xft/xftswap.c,v 1.1 2002/02/15 07:37:35 keithp Exp $ + * + * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 +#include "xftint.h" + +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; } + +void +XftSwapCARD32 (CARD32 *data, int u) +{ + char n; + while (u--) + { + swapl (data, n); + data++; + } +} + +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; + } + } +} + +void +XftSwapCARD16 (CARD16 *data, int u) +{ + char n; + while (u--) + { + swaps (data, n); + data++; + } +} + +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/src/xftxlfd.c b/src/xftxlfd.c new file mode 100644 index 0000000..87e500e --- /dev/null +++ b/src/xftxlfd.c @@ -0,0 +1,180 @@ +/* + * $XFree86: xc/lib/Xft/xftxlfd.c,v 1.9 2002/08/31 18:08:10 keithp Exp $ + * + * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. + * + * 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 +#include +#include +#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; +} + +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 0; + if (!(xlfd = strchr (foundry = ++xlfd, '-'))) return 0; + if (!(xlfd = strchr (family = ++xlfd, '-'))) return 0; + if (!(xlfd = strchr (weight_name = ++xlfd, '-'))) return 0; + if (!(xlfd = strchr (slant = ++xlfd, '-'))) return 0; + if (!(xlfd = strchr (/* setwidth_name = */ ++xlfd, '-'))) return 0; + if (!(xlfd = strchr (/* add_style_name = */ ++xlfd, '-'))) return 0; + if (!(xlfd = XftGetInt (++xlfd, &pixel))) return 0; + if (!(xlfd = XftGetInt (++xlfd, &point))) return 0; + if (!(xlfd = XftGetInt (++xlfd, &resx))) return 0; + if (!(xlfd = XftGetInt (++xlfd, &resy))) return 0; + if (!(xlfd = strchr (/* spacing = */ ++xlfd, '-'))) return 0; + if (!(xlfd = strchr (/* average_width = */ ++xlfd, '-'))) return 0; + if (!(xlfd = strchr (registry = ++xlfd, '-'))) return 0; + /* make sure no fields follow this one */ + if ((xlfd = strchr (encoding = ++xlfd, '-'))) return 0; + + if (!pixel) + return 0; + + pat = FcPatternCreate (); + if (!pat) + return 0; + + save = (char *) malloc (strlen (foundry) + 1); + + if (!save) + return 0; + + 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 0; +} diff --git a/xft-config.in b/xft-config.in new file mode 100644 index 0000000..6d40b04 --- /dev/null +++ b/xft-config.in @@ -0,0 +1,100 @@ +#! /bin/sh + +prefix="@prefix@" +exec_prefix="@exec_prefix@" +libdir="@libdir@" +includedir="@includedir@" +version="@PACKAGE_VERSION@" +freetypelibs="@FREETYPE_LIBS@" +freetypecflags="@FREETYPE_CFLAGS@" +fontconfiglibs="@FONTCONFIG_LIBS@" +fontconfigcflags="@FONTCONFIG_CFLAGS@" +xrenderlibs="@XRENDER_LIBS@" +xrendercflags="@XRENDER_CFLAGS@" + +usage() +{ + cat <&2 +fi + +while test $# -gt 0 ; do + case "$1" in + -*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;; + *) optarg= ;; + esac + + case $1 in + --prefix=*) + prefix=$optarg + local_prefix=yes + ;; + --prefix) + echo_prefix=yes + ;; + --exec-prefix=*) + exec_prefix=$optarg + exec_prefix_set=yes + local_prefix=yes + ;; + --exec-prefix) + echo_exec_prefix=yes + ;; + --version) + echo $version + exit 0 + ;; + --cflags) + echo_cflags=yes + ;; + --libs) + echo_libs=yes + ;; + *) + usage 1 1>&2 + ;; + esac + shift +done + +if test "$local_prefix" = "yes" ; then + if test "$exec_prefix_set" != "yes" ; then + exec_prefix=$prefix + fi +fi + +if test "$echo_prefix" = "yes" ; then + echo $prefix +fi + +if test "$echo_exec_prefix" = "yes" ; then + echo $exec_prefix +fi + +if test "$echo_cflags" = "yes" ; then + cflags="-I${includedir} ${freetypecflags} ${fontconfigcflags} ${xrendercflags}" + echo $cflags +fi + +if test "$echo_libs" = "yes" ; then + libs="-lXft ${freetypelibs} ${fontconfiglibs} ${xrenderlibs}" + if test "${libdir}" != "/usr/lib" ; then + echo -L${libdir} $libs + else + echo $libs + fi +fi + +# EOF diff --git a/xft.pc.in b/xft.pc.in new file mode 100644 index 0000000..c9c074c --- /dev/null +++ b/xft.pc.in @@ -0,0 +1,15 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ +freetypelibs=@FREETYPE_LIBS@ +freetypecflags=@FREETYPE_CFLAGS@ +xrenderlibs=@XRENDER_LIBS@ +xrendercflags=@XRENDER_CFLAGS@ + +Name: Xft +Description: X FreeType library +Version: @PACKAGE_VERSION@ +Requires: fontconfig +Libs: -L${libdir} -lXft ${freetypelibs} ${xrenderlibs} +Cflags: -I${includedir} ${freetypecflags} ${xrendercflags} -- cgit v1.2.1