From f4092abdf94af6a99aff944d6264bc1284e8bdd4 Mon Sep 17 00:00:00 2001
From: Reinhard Tartler <siretart@tauware.de>
Date: Mon, 10 Oct 2011 17:43:39 +0200
Subject: Imported nx-X11-3.1.0-1.tar.gz
Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:
Imported nx-X11-3.1.0-1.tar.gz
into Git repository
---
nx-X11/lib/Xft1/Imakefile | 150 ++++++++
nx-X11/lib/Xft1/Xft-def.cpp | 171 ++++++++++
nx-X11/lib/Xft1/Xft.h | 486 ++++++++++++++++++++++++++
nx-X11/lib/Xft1/Xft.man | 180 ++++++++++
nx-X11/lib/Xft1/XftConfig-OBSOLETE | 2 +
nx-X11/lib/Xft1/XftFreetype.h | 167 +++++++++
nx-X11/lib/Xft1/xftcache.c | 608 +++++++++++++++++++++++++++++++++
nx-X11/lib/Xft1/xftcfg.c | 36 ++
nx-X11/lib/Xft1/xftcolor.c | 125 +++++++
nx-X11/lib/Xft1/xftcore.c | 247 ++++++++++++++
nx-X11/lib/Xft1/xftdbg.c | 43 +++
nx-X11/lib/Xft1/xftdir.c | 42 +++
nx-X11/lib/Xft1/xftdpy.c | 436 ++++++++++++++++++++++++
nx-X11/lib/Xft1/xftdraw.c | 482 ++++++++++++++++++++++++++
nx-X11/lib/Xft1/xftextent.c | 190 +++++++++++
nx-X11/lib/Xft1/xftfont.c | 327 ++++++++++++++++++
nx-X11/lib/Xft1/xftfreetype.c | 678 +++++++++++++++++++++++++++++++++++++
nx-X11/lib/Xft1/xftfs.c | 44 +++
nx-X11/lib/Xft1/xftglyphs.c | 491 +++++++++++++++++++++++++++
nx-X11/lib/Xft1/xftgram.y | 452 +++++++++++++++++++++++++
nx-X11/lib/Xft1/xftinit.c | 42 +++
nx-X11/lib/Xft1/xftint.h | 508 +++++++++++++++++++++++++++
nx-X11/lib/Xft1/xftlex.l | 275 +++++++++++++++
nx-X11/lib/Xft1/xftlist.c | 166 +++++++++
nx-X11/lib/Xft1/xftmatch.c | 37 ++
nx-X11/lib/Xft1/xftmatrix.c | 104 ++++++
nx-X11/lib/Xft1/xftname.c | 59 ++++
nx-X11/lib/Xft1/xftpat.c | 243 +++++++++++++
nx-X11/lib/Xft1/xftrender.c | 527 ++++++++++++++++++++++++++++
nx-X11/lib/Xft1/xftstr.c | 259 ++++++++++++++
nx-X11/lib/Xft1/xftxlfd.c | 334 ++++++++++++++++++
31 files changed, 7911 insertions(+)
create mode 100644 nx-X11/lib/Xft1/Imakefile
create mode 100644 nx-X11/lib/Xft1/Xft-def.cpp
create mode 100644 nx-X11/lib/Xft1/Xft.h
create mode 100644 nx-X11/lib/Xft1/Xft.man
create mode 100644 nx-X11/lib/Xft1/XftConfig-OBSOLETE
create mode 100644 nx-X11/lib/Xft1/XftFreetype.h
create mode 100644 nx-X11/lib/Xft1/xftcache.c
create mode 100644 nx-X11/lib/Xft1/xftcfg.c
create mode 100644 nx-X11/lib/Xft1/xftcolor.c
create mode 100644 nx-X11/lib/Xft1/xftcore.c
create mode 100644 nx-X11/lib/Xft1/xftdbg.c
create mode 100644 nx-X11/lib/Xft1/xftdir.c
create mode 100644 nx-X11/lib/Xft1/xftdpy.c
create mode 100644 nx-X11/lib/Xft1/xftdraw.c
create mode 100644 nx-X11/lib/Xft1/xftextent.c
create mode 100644 nx-X11/lib/Xft1/xftfont.c
create mode 100644 nx-X11/lib/Xft1/xftfreetype.c
create mode 100644 nx-X11/lib/Xft1/xftfs.c
create mode 100644 nx-X11/lib/Xft1/xftglyphs.c
create mode 100644 nx-X11/lib/Xft1/xftgram.y
create mode 100644 nx-X11/lib/Xft1/xftinit.c
create mode 100644 nx-X11/lib/Xft1/xftint.h
create mode 100644 nx-X11/lib/Xft1/xftlex.l
create mode 100644 nx-X11/lib/Xft1/xftlist.c
create mode 100644 nx-X11/lib/Xft1/xftmatch.c
create mode 100644 nx-X11/lib/Xft1/xftmatrix.c
create mode 100644 nx-X11/lib/Xft1/xftname.c
create mode 100644 nx-X11/lib/Xft1/xftpat.c
create mode 100644 nx-X11/lib/Xft1/xftrender.c
create mode 100644 nx-X11/lib/Xft1/xftstr.c
create mode 100644 nx-X11/lib/Xft1/xftxlfd.c
(limited to 'nx-X11/lib/Xft1')
diff --git a/nx-X11/lib/Xft1/Imakefile b/nx-X11/lib/Xft1/Imakefile
new file mode 100644
index 000000000..dbb48cf45
--- /dev/null
+++ b/nx-X11/lib/Xft1/Imakefile
@@ -0,0 +1,150 @@
+XCOMM $XFree86: xc/lib/Xft1/Imakefile,v 1.13tsi Exp $
+
+XCOMM Allow for builds against old installed bits
+#ifdef UseInstalled
+
+#ifndef SharedLibXft1
+#define SharedLibXft1 YES
+#endif
+
+#ifndef NormalLibXft1
+#define NormalLibXft1 (!SharedLibXft1 | ForceNormalLib)
+#endif
+
+#ifndef DebugLibXft1
+#define DebugLibXft1 NO
+#endif
+
+#ifndef ProfileLibXft1
+#define ProfileLibXft1 NO
+#endif
+
+#ifndef FontconfigClientDepLibs
+#define FontconfigClientDepLibs $(DEPFONTCONFIGLIB)
+#endif
+#ifndef FontconfigClientLibs
+#define FontconfigClientLibs $(FONTCONFIGLIB)
+#endif
+
+#if SharedLibFontconfig
+#define SharedFontconfigRev 1.0
+
+SharedLibReferences(FONTCONFIG,fontconfig,$(FONTCONFIGSRC),SOXLIBREV,SharedFontconfigRev)
+#else
+
+ProjectUnsharedLibReferences(FONTCONFIG,fontconfig,$(FONTCONFIGSRC),BuildLibDir)
+#endif
+
+#if SharedLibXft1
+#define SharedXft1Rev 1.2
+SharedLibReferences(XFT1,Xft,$(XFT1SRC),SOXFT1REV,SharedXft1Rev)
+#else
+ProjectUnsharedLibReferences(XFT1,Xft,$(XFT1SRC),BuildLibDir)
+#endif
+
+#undef LinkBuildLibrary
+#define LinkBuildLibrary(lib) MakeDir($(BUILDLIBDIR)) @@\
+ RemoveFile($(BUILDLIBDIR)/lib) @@\
+ cd $(BUILDLIBDIR) && $(LN) $(BUILDLIBTOP)/$(CURRENT_DIR)/lib .
+#undef _LinkBuildLibrary
+#define _LinkBuildLibrary(lib) LinkBuildLibrary(lib)
+
+#undef LinkBuildLibraryMaybe
+#define LinkBuildLibraryMaybe(lib,doit) MakeDir($(BUILDLIBDIR)) @@\
+ @if doit; then (set -x; \ @@\
+ RemoveFile($(BUILDLIBDIR)/lib); \ @@\
+ cd $(BUILDLIBDIR) && $(LN) $(BUILDLIBTOP)/$(CURRENT_DIR)/lib .); fi
+
+#ifdef LdPreLibs
+# undef LdPreLibs
+#endif
+#define LdPreLibs -L$(BUILDLIBDIR) LdPreLib XLdPreLibs
+
+LDPRELIBS=LdPreLibs
+#endif
+
+
+#define DoNormalLib NO
+#define DoSharedLib SharedLibXft1
+#define DoExtraLib NO
+#define DoDebugLib NO
+#define DoProfileLib NO
+#define HasSharedData YES
+#define LibName Xft
+#define SoRev SOXFT1REV
+#define LibHeaders NO
+#define NoSoSymlink
+
+#include <Threads.tmpl>
+
+YFLAGS = -d
+
+#ifndef XftLibDir
+#define XftLibDir $(LIBDIR)
+#endif
+
+XFTLIBDIR=XftLibDir
+
+INCLUDES=$(FONTCONFIGINCLUDES) $(FREETYPE2INCLUDES) -I$(XBUILDINCDIR)
+DEFINES=$(FREETYPE2DEFINES) $(RENDERDEFINES) -DXFREE86_FT2
+
+#if UseFreetype2
+FREETYPE2REQLIB = $(FREETYPE2LIB)
+#endif
+
+REQUIREDLIBS=$(LDPRELIBS) $(XRENDERLIB) $(XLIB) $(FONTCONFIGLIB) $(EXPATLIB) $(FREETYPE2REQLIB)
+
+#if UseFreetype2
+FT_OLD = xftcache.c
+FT_HEADERS = XftFreetype.h
+ FT_SRCS = xftfreetype.c xftglyphs.c xftrender.c xftdir.c
+ FT_OBJS = xftfreetype.o xftglyphs.o xftrender.o xftdir.o
+#endif
+
+HEADERS = Xft.h $(FT_HEADERS)
+
+OLD = xftgram.c xftlex.c
+
+ SRCS = xftcfg.c xftcolor.c xftcore.c xftdbg.c xftdpy.c \
+ xftdraw.c xftextent.c xftfont.c xftfs.c\
+ xftinit.c xftlist.c xftmatch.c xftmatrix.c \
+ xftname.c xftpat.c xftstr.c xftxlfd.c $(FT_SRCS)
+
+ OBJS = xftcfg.o xftcolor.o xftcore.o xftdbg.o xftdpy.o \
+ xftdraw.o xftextent.o xftfont.o xftfs.o \
+ xftinit.o xftlist.o xftmatch.o xftmatrix.o \
+ xftname.o xftpat.o xftstr.o xftxlfd.o $(FT_OBJS)
+
+#include <Library.tmpl>
+
+#if DoSharedLib && SharedDataSeparation
+SpecialCObjectRule(sharedlib,NullParameter,$(SHLIBDEF))
+#endif
+
+/*
+ * InstallNamedTargetRelated - like InstallNamedTarget, but only
+ * installs if a related file already exists. Useful for
+ * annotating older systems with information on the relationship
+ * with the new system.
+ */
+
+#ifndef InstallNamedTargetRelated
+#define InstallNamedTargetRelated(step,srcname,flags,dest,dstname,dstrel)@@\
+step:: srcname @@\
+ MakeDir($(DESTDIR)dest) @@\
+ @if [ -f $(DESTDIR)dest/dstrel ]; then \ @@\
+ set -x; \ @@\
+ $(INSTALL) $(INSTALLFLAGS) flags srcname $(DESTDIR)dest/dstname; fi
+#endif
+
+#ifndef InstallNonExecFileRelated
+#define InstallNonExecFileRelated(file,dest,rel) @@\
+InstallNamedTargetRelated(install,file,$(INSTDATFLAGS),dest,file,rel)
+#endif /* InstallNonExecFileBackup */
+
+InstallNonExecFileRelated(XftConfig-OBSOLETE,$(XFTLIBDIR),XftConfig)
+InstallNonExecFileRelated(XftConfig-OBSOLETE,$(CONFDIR),XftConfig)
+
+MANSUFFIX = $(LIBMANSUFFIX)
+InstallManPage(Xft,$(LIBMANDIR))
+DependTarget()
diff --git a/nx-X11/lib/Xft1/Xft-def.cpp b/nx-X11/lib/Xft1/Xft-def.cpp
new file mode 100644
index 000000000..410b8202b
--- /dev/null
+++ b/nx-X11/lib/Xft1/Xft-def.cpp
@@ -0,0 +1,171 @@
+LIBRARY Xft
+VERSION LIBRARY_VERSION
+EXPORTS
+
+#ifndef __UNIXOS2__
+XftConfigAddDir
+XftConfigAddEdit
+XftConfigGetCache
+XftConfigSetCache
+XftConfigSubstitute
+_XftConfigCompareValue
+#endif
+XftColorAllocName
+XftColorAllocValue
+XftColorFree
+#ifndef __UNIXOS2__
+XftCoreConvert16
+XftCoreConvert32
+XftCoreConvertUtf8
+XftCoreExtents16
+XftCoreExtents32
+XftCoreExtents8
+XftCoreExtentsUtf8
+XftCoreGlyphExists
+XftEditPrint
+XftExprPrint
+XftFontSetPrint
+XftOpPrint
+XftPatternPrint
+XftSubstPrint
+XftTestPrint
+XftValueListPrint
+XftValuePrint
+#endif
+XftDefaultGetBool
+XftDefaultGetDouble
+XftDefaultGetInteger
+XftDefaultHasRender
+XftDefaultParseBool
+XftDefaultSet
+XftDefaultSubstitute
+#ifndef __UNIXOS2__
+XftDisplayGetFontSet
+#endif
+XftDrawChange
+#ifndef __UNIXOS2__
+XftDrawCorePrepare
+#endif
+XftDrawCreate
+XftDrawCreateBitmap
+XftDrawDestroy
+XftDrawRect
+#ifndef __UNIXOS2__
+XftDrawRenderPrepare
+#endif
+XftDrawSetClip
+XftDrawString16
+XftDrawString32
+XftDrawString8
+XftDrawStringUtf8
+XftTextExtents16
+XftTextExtents32
+XftTextExtents8
+XftTextExtentsUtf8
+XftFontClose
+XftFontMatch
+XftFontOpen
+XftFontOpenName
+XftFontOpenPattern
+XftFontOpenXlfd
+#ifndef __UNIXOS2__
+XftGlyphExists
+_XftFontDebug
+XftFontSetAdd
+XftFontSetCreate
+XftFontSetDestroy
+XftConfigSaveField
+XftConfigerror
+XftConfigparse
+XftConfigwrap
+XftEditCreate
+XftEditDestroy
+XftExprCreateBool
+XftExprCreateDouble
+XftExprCreateField
+XftExprCreateInteger
+XftExprCreateNil
+XftExprCreateOp
+XftExprCreateString
+XftExprDestroy
+XftTestCreate
+#endif
+XftInit
+#ifndef __UNIXOS2__
+XftConfigLexFile
+XftConfigPushInput
+XftConfig_create_buffer
+XftConfig_delete_buffer
+XftConfig_flush_buffer
+XftConfig_init_buffer
+XftConfig_load_buffer_state
+XftConfig_scan_buffer
+XftConfig_scan_bytes
+XftConfig_scan_string
+XftConfig_switch_to_buffer
+XftConfiglex
+XftConfigrestart
+XftListAppend
+XftListFontSets
+#endif
+XftListFonts
+XftListFontsPatternObjects
+#ifndef __UNIXOS2__
+XftListMatch
+XftListValueCompare
+XftListValueListCompare
+XftObjectSetAdd
+XftObjectSetBuild
+XftObjectSetCreate
+XftObjectSetDestroy
+XftObjectSetVaBuild
+XftFontSetMatch
+XftNameConstant
+#endif
+XftNameParse
+XftNameUnparse
+#ifndef __UNIXOS2__
+XftPatternAdd
+XftPatternAddBool
+XftPatternAddDouble
+XftPatternAddInteger
+XftPatternAddString
+XftPatternBuild
+XftPatternCreate
+XftPatternDel
+XftPatternDestroy
+XftPatternDuplicate
+XftPatternFind
+XftPatternGet
+XftPatternGetBool
+XftPatternGetDouble
+XftPatternGetInteger
+XftPatternGetString
+XftPatternVaBuild
+XftValueDestroy
+XftValueListDestroy
+XftUtf8Len
+XftUtf8ToUcs4
+_XftDownStr
+_XftGetInt
+#endif
+_XftMatchSymbolic
+#ifndef __UNIXOS2__
+_XftSaveString
+_XftSplitField
+_XftSplitStr
+_XftSplitValue
+_XftStrCmpIgnoreCase
+XftCoreAddFonts
+XftCoreClose
+XftCoreOpen
+#endif
+XftXlfdParse
+XftInitFtLibrary
+#ifndef __UNIXOS2__
+XftConfigDirs
+XftDirScan
+XftDirSave
+#endif
+
+/* $XFree86: xc/lib/Xft/Xft-def.cpp,v 1.4 2002/09/18 01:25:00 dawes Exp $ */
diff --git a/nx-X11/lib/Xft1/Xft.h b/nx-X11/lib/Xft1/Xft.h
new file mode 100644
index 000000000..71ef9b80c
--- /dev/null
+++ b/nx-X11/lib/Xft1/Xft.h
@@ -0,0 +1,486 @@
+/*
+ * $XFree86: xc/lib/Xft/Xft.h,v 1.19 2001/04/29 03:21:17 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.
+ */
+
+#ifndef _XFT_H_
+#define _XFT_H_
+
+#include <X11/extensions/Xrender.h>
+#include <fontconfig/fontconfig.h>
+#include <stdarg.h>
+
+#include <X11/Xfuncproto.h>
+#include <X11/Xosdefs.h>
+
+typedef unsigned char XftChar8;
+typedef unsigned short XftChar16;
+typedef unsigned int XftChar32;
+
+#define XFT_FAMILY "family" /* String */
+#define XFT_STYLE "style" /* String */
+#define XFT_SLANT "slant" /* Int */
+#define XFT_WEIGHT "weight" /* Int */
+#define XFT_SIZE "size" /* Double */
+#define XFT_PIXEL_SIZE "pixelsize" /* Double */
+#define XFT_ENCODING "encoding" /* String */
+#define XFT_SPACING "spacing" /* Int */
+#define XFT_FOUNDRY "foundry" /* String */
+#define XFT_CORE "core" /* Bool */
+#define XFT_ANTIALIAS "antialias" /* Bool */
+#define XFT_XLFD "xlfd" /* String */
+#define XFT_FILE "file" /* String */
+#define XFT_INDEX "index" /* Int */
+#define XFT_RASTERIZER "rasterizer"/* String */
+#define XFT_OUTLINE "outline" /* Bool */
+#define XFT_SCALABLE "scalable" /* Bool */
+#define XFT_RGBA "rgba" /* Int */
+
+/* defaults from resources */
+#define XFT_SCALE "scale" /* double */
+#define XFT_RENDER "render" /* Bool */
+#define XFT_MINSPACE "minspace" /* Bool use minimum line spacing */
+#define XFT_DPI "dpi" /* double */
+
+/* specific to FreeType rasterizer */
+#define XFT_CHAR_WIDTH "charwidth" /* Int */
+#define XFT_CHAR_HEIGHT "charheight"/* Int */
+#define XFT_MATRIX "matrix" /* XftMatrix */
+
+#define XFT_WEIGHT_LIGHT 0
+#define XFT_WEIGHT_MEDIUM 100
+#define XFT_WEIGHT_DEMIBOLD 180
+#define XFT_WEIGHT_BOLD 200
+#define XFT_WEIGHT_BLACK 210
+
+#define XFT_SLANT_ROMAN 0
+#define XFT_SLANT_ITALIC 100
+#define XFT_SLANT_OBLIQUE 110
+
+#define XFT_PROPORTIONAL 0
+#define XFT_MONO 100
+#define XFT_CHARCELL 110
+
+#define XFT_RGBA_NONE 0
+#define XFT_RGBA_RGB 1
+#define XFT_RGBA_BGR 2
+#define XFT_RGBA_VRGB 3
+#define XFT_RGBA_VBGR 4
+
+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
+
+#define XftTypeVoid FcTypeVoid
+#define XftTypeInteger FcTypeInteger
+#define XftTypeDouble FcTypeDouble
+#define XftTypeString FcTypeString
+#define XftTypeBool FcTypeBool
+#define XftTypeMatrix FcTypeMatrix
+
+typedef FcValue XftValue;
+
+
+typedef FcPattern XftPattern;
+
+typedef FcFontSet XftFontSet;
+
+typedef struct _XftFontStruct XftFontStruct;
+
+typedef struct _XftFont {
+ int ascent;
+ int descent;
+ int height;
+ int max_advance_width;
+ Bool core;
+ XftPattern *pattern;
+ union {
+ struct {
+ XFontStruct *font;
+ } core;
+ struct {
+ XftFontStruct *font;
+ } ft;
+ } u;
+} XftFont;
+
+typedef struct _XftDraw XftDraw;
+
+typedef struct _XftColor {
+ unsigned long pixel;
+ XRenderColor color;
+} XftColor;
+
+typedef FcObjectSet XftObjectSet;
+
+_XFUNCPROTOBEGIN
+
+/* xftcfg.c */
+Bool
+XftConfigSubstitute (XftPattern *p);
+
+/* xftcolor.c */
+Bool
+XftColorAllocName (Display *dpy,
+ Visual *visual,
+ Colormap cmap,
+ char *name,
+ XftColor *result);
+
+Bool
+XftColorAllocValue (Display *dpy,
+ Visual *visual,
+ Colormap cmap,
+ XRenderColor *color,
+ XftColor *result);
+
+void
+XftColorFree (Display *dpy,
+ Visual *visual,
+ Colormap cmap,
+ XftColor *color);
+
+
+/* xftcore.c */
+/* xftdbg.c */
+void
+XftValuePrint (XftValue v);
+
+void
+XftPatternPrint (XftPattern *p);
+
+void
+XftFontSetPrint (XftFontSet *s);
+
+/* xftdir.c */
+/* xftdpy.c */
+Bool
+XftDefaultHasRender (Display *dpy);
+
+Bool
+XftDefaultSet (Display *dpy, XftPattern *defaults);
+
+void
+XftDefaultSubstitute (Display *dpy, int screen, XftPattern *pattern);
+
+/* xftdraw.c */
+
+XftDraw *
+XftDrawCreate (Display *dpy,
+ Drawable drawable,
+ Visual *visual,
+ Colormap colormap);
+
+XftDraw *
+XftDrawCreateBitmap (Display *dpy,
+ Pixmap bitmap);
+
+void
+XftDrawChange (XftDraw *draw,
+ Drawable drawable);
+
+void
+XftDrawDestroy (XftDraw *draw);
+
+void
+XftDrawString8 (XftDraw *d,
+ XftColor *color,
+ XftFont *font,
+ int x,
+ int y,
+ XftChar8 *string,
+ int len);
+
+void
+XftDrawString16 (XftDraw *draw,
+ XftColor *color,
+ XftFont *font,
+ int x,
+ int y,
+ XftChar16 *string,
+ int len);
+
+void
+XftDrawString32 (XftDraw *draw,
+ XftColor *color,
+ XftFont *font,
+ int x,
+ int y,
+ XftChar32 *string,
+ int len);
+
+void
+XftDrawStringUtf8 (XftDraw *d,
+ XftColor *color,
+ XftFont *font,
+ int x,
+ int y,
+ XftChar8 *string,
+ int len);
+
+void
+XftDrawRect (XftDraw *d,
+ XftColor *color,
+ int x,
+ int y,
+ unsigned int width,
+ unsigned int height);
+
+
+Bool
+XftDrawSetClip (XftDraw *d,
+ Region r);
+
+/* xftextent.c */
+
+void
+XftTextExtents8 (Display *dpy,
+ XftFont *font,
+ XftChar8 *string,
+ int len,
+ XGlyphInfo *extents);
+
+void
+XftTextExtents16 (Display *dpy,
+ XftFont *font,
+ XftChar16 *string,
+ int len,
+ XGlyphInfo *extents);
+
+void
+XftTextExtents32 (Display *dpy,
+ XftFont *font,
+ XftChar32 *string,
+ int len,
+ XGlyphInfo *extents);
+
+void
+XftTextExtentsUtf8 (Display *dpy,
+ XftFont *font,
+ XftChar8 *string,
+ int len,
+ XGlyphInfo *extents);
+
+/* xftfont.c */
+XftPattern *
+XftFontMatch (Display *dpy, int screen, XftPattern *pattern, XftResult *result);
+
+XftFont *
+XftFontOpenPattern (Display *dpy, XftPattern *pattern);
+
+XftFont *
+XftFontOpen (Display *dpy, int screen, ...);
+
+XftFont *
+XftFontOpenName (Display *dpy, int screen, const char *name);
+
+XftFont *
+XftFontOpenXlfd (Display *dpy, int screen, const char *xlfd);
+
+void
+XftFontClose (Display *dpy, XftFont *font);
+
+Bool
+XftGlyphExists (Display *dpy, XftFont *font, XftChar32 glyph);
+
+/* xftfreetype.c */
+/* xftfs.c */
+
+XftFontSet *
+XftFontSetCreate (void);
+
+void
+XftFontSetDestroy (XftFontSet *s);
+
+Bool
+XftFontSetAdd (XftFontSet *s, XftPattern *font);
+
+/* xftglyphs.c */
+/* see XftFreetype.h */
+
+/* xftgram.y */
+
+/* xftinit.c */
+Bool
+XftInit (char *config);
+
+/* xftlex.l */
+
+/* xftlist.c */
+XftObjectSet *
+XftObjectSetCreate (void);
+
+Bool
+XftObjectSetAdd (XftObjectSet *os, const char *object);
+
+void
+XftObjectSetDestroy (XftObjectSet *os);
+
+XftObjectSet *
+XftObjectSetVaBuild (const char *first, va_list va);
+
+XftObjectSet *
+XftObjectSetBuild (const char *first, ...);
+
+XftFontSet *
+XftListFontSets (XftFontSet **sets,
+ int nsets,
+ XftPattern *p,
+ XftObjectSet *os);
+
+XftFontSet *
+XftListFontsPatternObjects (Display *dpy,
+ int screen,
+ XftPattern *pattern,
+ XftObjectSet *os);
+
+XftFontSet *
+XftListFonts (Display *dpy,
+ int screen,
+ ...);
+
+/* xftmatch.c */
+XftPattern *
+XftFontSetMatch (XftFontSet **sets,
+ int nsets,
+ XftPattern *p,
+ XftResult *result);
+
+/* xftmatrix.c */
+int
+XftMatrixEqual (const XftMatrix *mat1, const XftMatrix *mat2);
+
+void
+XftMatrixMultiply (XftMatrix *result, XftMatrix *a, XftMatrix *b);
+
+void
+XftMatrixRotate (XftMatrix *m, double c, double s);
+
+void
+XftMatrixScale (XftMatrix *m, double sx, double sy);
+
+void
+XftMatrixShear (XftMatrix *m, double sh, double sv);
+
+/* xftname.c */
+XftPattern *
+XftNameParse (const char *name);
+
+Bool
+XftNameUnparse (XftPattern *pat, char *dest, int len);
+
+/* xftpat.c */
+XftPattern *
+XftPatternCreate (void);
+
+XftPattern *
+XftPatternDuplicate (XftPattern *p);
+
+void
+XftValueDestroy (XftValue v);
+
+void
+XftPatternDestroy (XftPattern *p);
+
+Bool
+XftPatternAdd (XftPattern *p, const char *object, XftValue value, Bool append);
+
+XftResult
+XftPatternGet (XftPattern *p, const char *object, int id, XftValue *v);
+
+Bool
+XftPatternDel (XftPattern *p, const char *object);
+
+Bool
+XftPatternAddInteger (XftPattern *p, const char *object, int i);
+
+Bool
+XftPatternAddDouble (XftPattern *p, const char *object, double d);
+
+Bool
+XftPatternAddString (XftPattern *p, const char *object, const char *s);
+
+Bool
+XftPatternAddMatrix (XftPattern *p, const char *object, const XftMatrix *s);
+
+Bool
+XftPatternAddBool (XftPattern *p, const char *object, Bool b);
+
+XftResult
+XftPatternGetInteger (XftPattern *p, const char *object, int n, int *i);
+
+XftResult
+XftPatternGetDouble (XftPattern *p, const char *object, int n, double *d);
+
+XftResult
+XftPatternGetString (XftPattern *p, const char *object, int n, char **s);
+
+XftResult
+XftPatternGetMatrix (XftPattern *p, const char *object, int n, XftMatrix **s);
+
+XftResult
+XftPatternGetBool (XftPattern *p, const char *object, int n, Bool *b);
+
+XftPattern *
+XftPatternVaBuild (XftPattern *orig, va_list va);
+
+XftPattern *
+XftPatternBuild (XftPattern *orig, ...);
+
+/* xftrender.c */
+/* see XftFreetype.h */
+
+/* xftstr.c */
+
+int
+XftUtf8ToUcs4 (XftChar8 *src_orig,
+ XftChar32 *dst,
+ int len);
+
+Bool
+XftUtf8Len (XftChar8 *string,
+ int len,
+ int *nchar,
+ int *wchar);
+
+/* xftxlfd.c */
+XftPattern *
+XftXlfdParse (const char *xlfd_orig, Bool ignore_scalable, Bool complete);
+
+XFontStruct *
+XftCoreOpen (Display *dpy, XftPattern *pattern);
+
+void
+XftCoreClose (Display *dpy, XFontStruct *font);
+
+_XFUNCPROTOEND
+
+#endif /* _XFT_H_ */
diff --git a/nx-X11/lib/Xft1/Xft.man b/nx-X11/lib/Xft1/Xft.man
new file mode 100644
index 000000000..7d62818a2
--- /dev/null
+++ b/nx-X11/lib/Xft1/Xft.man
@@ -0,0 +1,180 @@
+.\"
+.\" $XFree86: xc/lib/Xft/Xft.man,v 1.2 2000/11/30 06:59:45 keithp Exp $
+.\"
+.\" Copyright © 2000 Keith Packard.
+.\" Permission to use, copy, modify, distribute, and sell this software and its
+.\" documentation for any purpose is hereby granted without fee, provided that
+.\" the above copyright notice appear in all copies and that both that
+.\" copyright notice and this permission notice appear in supporting
+.\" documentation, and that the name of Keith Packard not be used in
+.\" advertising or publicity pertaining to distribution of the software without
+.\" specific, written prior permission. Keith Packard makes no
+.\" representations about the suitability of this software for any purpose. It
+.\" is provided "as is" without express or implied warranty.
+.\"
+.\" KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+.\" INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+.\" EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+.\" CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+.\" DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+.\" TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+.\" PERFORMANCE OF THIS SOFTWARE.
+.\"
+.de TQ
+.br
+.ns
+.TP \\$1
+..
+.TH XFT __libmansuffix__ __vendorversion__
+
+.SH NAME
+ XFT \- X FreeType interface library
+
+.SH DESCRIPTION
+.B Xft
+is a simple library designed to interface the FreeType rasterizer with the X
+Rendering Extension. This manual page barely scratches the surface of this
+library.
+
+.SH DATATYPES
+
+.B XftPattern
+holds a set of names with associated value lists; each name refers to a
+property of a font. XftPatterns are used as inputs to the matching code as
+well as holding information about specific fonts.
+
+.B XftFont
+contains general font metrics and a pointer to either the core XFontStruct
+data or a structure holding FreeType and X Render Extension data.
+
+.B XftFontStruct
+contains information about FreeType fonts used with the X Render Extension.
+
+.B XftFontSet
+contains a list of XftPatterns. Internally Xft uses this data structure to
+hold sets of fonts. Externally, Xft returns the results of listing fonts in
+this format.
+
+.B XftObjectSet
+holds a set of names and is used to specify which fields from fonts are
+placed in the the list of returned patterns when listing fonts.
+
+.B XftDraw
+is an opaque object which holds information used to render to an X drawable
+using either core protocol or the X Rendering extension.
+
+.SH FUNCTIONS
+.nf
+XftFont *
+XftFontOpen (Display *dpy, int screen, ...);
+.fi
+.B XftFontOpen
+takes a list of pattern elements of the form (field, type, value) terminated
+with a 0, matches that pattern against the available fonts and opens the
+matching font.
+.PP
+Example:
+.br
+ font = XftFontOpen (dpy, scr,
+ XFT_FAMILY, XftTypeString, "charter",
+ XFT_SIZE, XftTypeDouble, 12.0);
+.PP
+This opens the charter font at 12 points. The point size is automatically
+converted to the correct pixel size based on the resolution of the monitor.
+.PP
+.nf
+void
+XftTextExtents8 (Display *dpy,
+ XftFont *font,
+ unsigned char *string,
+ int len,
+ XGlyphInfo *extents);
+.fi
+.B XftTextExtents8
+computes the pixel extents of "string" when drawn with "font".
+.PP
+.nf
+XftDraw *
+XftDrawCreate (Display *dpy,
+ Drawable drawable,
+ Visual *visual,
+ Colormap colormap);
+.fi
+.B XtDrawCreate
+creates a structure that can be used to render text and rectangles
+to the screen.
+.PP
+.nf
+void
+XftDrawString8 (XftDraw *d,
+ XRenderColor *color,
+ XftFont *font,
+ int x,
+ int y,
+ unsigned char *string,
+ int len);
+.fi
+.B XftDrawString8
+draws "string" using "font" in "color" at "x, y".
+.PP
+.nf
+void
+XftDrawRect (XftDraw *d,
+ XRenderColor *color,
+ int x,
+ int y,
+ unsigned int width,
+ unsigned int height);
+.fi
+.B XftDrawRect
+fills a solid rectangle in the specified color.
+.SH XftConfig
+The
+.B XftConfig
+file contains configuration information for the Xft library consisting of
+directories to look at for font information as well as instructions on
+editing program specified font patterns before attempting to match the
+available fonts.
+.PP
+.nf
+config : "dir" STRING
+ | "include" STRING
+ | "includeif" STRING
+ | "match" tests "edit" edits
+ ;
+test : qual FIELD-NAME COMPARE CONSTANT
+ ;
+qual : "any"
+ | "all"
+ ;
+edit : FIELD-NAME ASSIGN expr SEMI
+ ;
+.fi
+.PP
+STRINGs are double-quote delimited. FIELD-NAMEs are identifiers,
+ASSIGN is one of "=", "+=" or "=+". expr can contain the usual
+arithmetic operators and can include FIELD-NAMEs.
+.PP
+"dir" adds a directory to the list of places Xft will look for fonts.
+There is no particular order implied by the list; Xft treats all fonts about
+the same.
+.PP
+"include" and "includeif" cause Xft to load more configuration parameters
+from the indicated file. "includeif" doesn't elicit a complaint if the file
+doesn't exist. If the file name begins with a '~' character, it refers to a
+path relative to the home directory of the user.
+.PP
+If the tests in a "match" statement all match a user-specified pattern, the
+pattern will be edited with the specified instructions.
+.PP
+Where ASSIGN is "=", the matching value in the pattern will be replaced by
+the given expression. "+="/"=+" will prepend/append a new value to the list
+of values for the indicated field.
+
+.SH RESTRICTIONS
+.B Xft
+will probably change radically in the future; weak attempts will be made to
+retain some level of source-file compatibility.
+
+.SH AUTHOR
+Keith Packard
diff --git a/nx-X11/lib/Xft1/XftConfig-OBSOLETE b/nx-X11/lib/Xft1/XftConfig-OBSOLETE
new file mode 100644
index 000000000..ec90d1bfe
--- /dev/null
+++ b/nx-X11/lib/Xft1/XftConfig-OBSOLETE
@@ -0,0 +1,2 @@
+The XftConfig file is no longer used by Xft. Please see
+/etc/fonts/fonts.conf to configure client-side fonts.
diff --git a/nx-X11/lib/Xft1/XftFreetype.h b/nx-X11/lib/Xft1/XftFreetype.h
new file mode 100644
index 000000000..07fed47e4
--- /dev/null
+++ b/nx-X11/lib/Xft1/XftFreetype.h
@@ -0,0 +1,167 @@
+/*
+ * $XFree86: xc/lib/Xft1/XftFreetype.h,v 1.3 2002/03/02 22:09:04 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.
+ */
+
+#ifndef _XFTFREETYPE_H_
+#define _XFTFREETYPE_H_
+
+#include "Xft.h"
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#include <X11/Xfuncproto.h>
+#include <X11/Xosdefs.h>
+
+extern FT_Library _XftFTlibrary;
+
+struct _XftFontStruct {
+ FT_Face face; /* handle to face object */
+ GlyphSet glyphset;
+ int min_char;
+ int max_char;
+ FT_F26Dot6 size;
+ int ascent;
+ int descent;
+ int height;
+ int max_advance_width;
+ int spacing;
+ int rgba;
+ Bool antialias;
+ int charmap; /* -1 for unencoded */
+ XRenderPictFormat *format;
+ XGlyphInfo **realized;
+ int nrealized;
+ Bool transform;
+ FT_Matrix matrix;
+};
+
+#define XftUntestedGlyph ((XGlyphInfo *) 1)
+
+_XFUNCPROTOBEGIN
+
+/* xftdir.c */
+Bool
+XftDirScan (XftFontSet *set, const char *dir, Bool force);
+
+Bool
+XftDirSave (XftFontSet *set, const char *dir);
+
+/* xftfreetype.c */
+XftPattern *
+XftFreeTypeQuery (const char *file, int id, int *count);
+
+Bool
+XftFreeTypeSetFace (FT_Face face, FT_F26Dot6 size, int charmap, FT_Matrix *matrix);
+
+XftFontStruct *
+XftFreeTypeOpen (Display *dpy, XftPattern *pattern);
+
+void
+XftFreeTypeClose (Display *dpy, XftFontStruct *font);
+
+XftFontStruct *
+XftFreeTypeGet (XftFont *font);
+
+Bool
+XftInitFtLibrary(void);
+
+/* xftglyphs.c */
+void
+XftGlyphLoad (Display *dpy,
+ XftFontStruct *font,
+ XftChar32 *glyphs,
+ int nglyph);
+
+void
+XftGlyphCheck (Display *dpy,
+ XftFontStruct *font,
+ XftChar32 glyph,
+ XftChar32 *missing,
+ int *nmissing);
+
+Bool
+XftFreeTypeGlyphExists (Display *dpy,
+ XftFontStruct *font,
+ XftChar32 glyph);
+
+/* xftrender.c */
+
+void
+XftRenderString8 (Display *dpy, Picture src,
+ XftFontStruct *font, Picture dst,
+ int srcx, int srcy,
+ int x, int y,
+ XftChar8 *string, int len);
+
+void
+XftRenderString16 (Display *dpy, Picture src,
+ XftFontStruct *font, Picture dst,
+ int srcx, int srcy,
+ int x, int y,
+ XftChar16 *string, int len);
+
+void
+XftRenderString32 (Display *dpy, Picture src,
+ XftFontStruct *font, Picture dst,
+ int srcx, int srcy,
+ int x, int y,
+ XftChar32 *string, int len);
+
+void
+XftRenderStringUtf8 (Display *dpy, Picture src,
+ XftFontStruct *font, Picture dst,
+ int srcx, int srcy,
+ int x, int y,
+ XftChar8 *string, int len);
+
+void
+XftRenderExtents8 (Display *dpy,
+ XftFontStruct *font,
+ XftChar8 *string,
+ int len,
+ XGlyphInfo *extents);
+
+void
+XftRenderExtents16 (Display *dpy,
+ XftFontStruct *font,
+ XftChar16 *string,
+ int len,
+ XGlyphInfo *extents);
+
+void
+XftRenderExtents32 (Display *dpy,
+ XftFontStruct *font,
+ XftChar32 *string,
+ int len,
+ XGlyphInfo *extents);
+
+void
+XftRenderExtentsUtf8 (Display *dpy,
+ XftFontStruct *font,
+ XftChar8 *string,
+ int len,
+ XGlyphInfo *extents);
+
+_XFUNCPROTOEND
+
+#endif /* _XFTFREETYPE_H_ */
diff --git a/nx-X11/lib/Xft1/xftcache.c b/nx-X11/lib/Xft1/xftcache.c
new file mode 100644
index 000000000..13e20a92b
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftcache.c
@@ -0,0 +1,608 @@
+/*
+ * $XFree86: xc/lib/Xft/xftcache.c,v 1.2 2001/06/11 22:53:30 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 <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include "xftint.h"
+
+typedef struct _XftFileCacheEnt {
+ struct _XftFileCacheEnt *next;
+ unsigned int hash;
+ char *file;
+ int id;
+ time_t time;
+ char *name;
+ Bool referenced;
+} XftFileCacheEnt;
+
+#define HASH_SIZE 509
+
+typedef struct _XftFileCache {
+ XftFileCacheEnt *ents[HASH_SIZE];
+ Bool updated;
+ int entries;
+ int referenced;
+} XftFileCache;
+
+static XftFileCache _XftFileCache;
+
+static unsigned int
+_XftFileCacheHash (char *string)
+{
+ unsigned int h = 0;
+ char c;
+
+ while ((c = *string++))
+ h = (h << 1) ^ c;
+ return h;
+}
+
+char *
+XftFileCacheFind (char *file, int id, int *count)
+{
+ XftFileCache *cache;
+ unsigned int hash;
+ char *match;
+ XftFileCacheEnt *c, *name;
+ int maxid;
+ struct stat statb;
+
+ cache = &_XftFileCache;
+ match = file;
+
+ hash = _XftFileCacheHash (match);
+ name = 0;
+ maxid = -1;
+ for (c = cache->ents[hash % HASH_SIZE]; c; c = c->next)
+ {
+ if (c->hash == hash && !strcmp (match, c->file))
+ {
+ if (c->id > maxid)
+ maxid = c->id;
+ if (c->id == id)
+ {
+ if (stat (file, &statb) < 0)
+ {
+ if (_XftFontDebug () & XFT_DBG_CACHE)
+ printf (" file missing\n");
+ return 0;
+ }
+ if (statb.st_mtime != c->time)
+ {
+ if (_XftFontDebug () & XFT_DBG_CACHE)
+ printf (" timestamp mismatch (was %d is %d)\n",
+ (int) c->time, (int) statb.st_mtime);
+ return 0;
+ }
+ if (!c->referenced)
+ {
+ cache->referenced++;
+ c->referenced = True;
+ }
+ name = c;
+ }
+ }
+ }
+ if (!name)
+ return 0;
+ *count = maxid + 1;
+ return name->name;
+}
+
+/*
+ * Cache file syntax is quite simple:
+ *
+ * "file_name" id time "font_name" \n
+ */
+
+static Bool
+_XftFileCacheReadString (FILE *f, char *dest, int len)
+{
+ int c;
+ Bool escape;
+
+ while ((c = getc (f)) != EOF)
+ if (c == '"')
+ break;
+ if (c == EOF)
+ return False;
+ if (len == 0)
+ return False;
+
+ escape = False;
+ while ((c = getc (f)) != EOF)
+ {
+ if (!escape)
+ {
+ switch (c) {
+ case '"':
+ *dest++ = '\0';
+ return True;
+ case '\\':
+ escape = True;
+ continue;
+ }
+ }
+ if (--len <= 1)
+ return False;
+ *dest++ = c;
+ escape = False;
+ }
+ return False;
+}
+
+static Bool
+_XftFileCacheReadUlong (FILE *f, unsigned long *dest)
+{
+ unsigned long t;
+ int c;
+
+ while ((c = getc (f)) != EOF)
+ {
+ if (!isspace (c))
+ break;
+ }
+ if (c == EOF)
+ return False;
+ t = 0;
+ for (;;)
+ {
+ if (c == EOF || isspace (c))
+ break;
+ if (!isdigit (c))
+ return False;
+ t = t * 10 + (c - '0');
+ c = getc (f);
+ }
+ *dest = t;
+ return True;
+}
+
+static Bool
+_XftFileCacheReadInt (FILE *f, int *dest)
+{
+ unsigned long t;
+ Bool ret;
+
+ ret = _XftFileCacheReadUlong (f, &t);
+ if (ret)
+ *dest = (int) t;
+ return ret;
+}
+
+static Bool
+_XftFileCacheReadTime (FILE *f, time_t *dest)
+{
+ unsigned long t;
+ Bool ret;
+
+ ret = _XftFileCacheReadUlong (f, &t);
+ if (ret)
+ *dest = (time_t) t;
+ return ret;
+}
+
+static Bool
+_XftFileCacheAdd (XftFileCache *cache,
+ char *file,
+ int id,
+ time_t time,
+ char *name,
+ Bool replace)
+{
+ XftFileCacheEnt *c;
+ XftFileCacheEnt **prev, *old;
+ unsigned int hash;
+
+ if (_XftFontDebug () & XFT_DBG_CACHE)
+ {
+ printf ("%s face %s/%d as %s\n", replace ? "Replace" : "Add",
+ file, id, name);
+ }
+ hash = _XftFileCacheHash (file);
+ for (prev = &cache->ents[hash % HASH_SIZE];
+ (old = *prev);
+ prev = &(*prev)->next)
+ {
+ if (old->hash == hash && old->id == id && !strcmp (old->file, file))
+ break;
+ }
+ if (*prev)
+ {
+ if (!replace)
+ return False;
+
+ old = *prev;
+ if (old->referenced)
+ cache->referenced--;
+ *prev = old->next;
+ free (old);
+ cache->entries--;
+ }
+
+ c = malloc (sizeof (XftFileCacheEnt) +
+ strlen (file) + 1 +
+ strlen (name) + 1);
+ if (!c)
+ return False;
+ c->next = *prev;
+ *prev = c;
+ c->hash = hash;
+ c->file = (char *) (c + 1);
+ c->id = id;
+ c->name = c->file + strlen (file) + 1;
+ strcpy (c->file, file);
+ c->time = time;
+ c->referenced = replace;
+ strcpy (c->name, name);
+ cache->entries++;
+ return True;
+}
+
+void
+XftFileCacheDispose (void)
+{
+ XftFileCache *cache;
+ XftFileCacheEnt *c, *next;
+ int h;
+
+ cache = &_XftFileCache;
+
+ for (h = 0; h < HASH_SIZE; h++)
+ {
+ for (c = cache->ents[h]; c; c = next)
+ {
+ next = c->next;
+ free (c);
+ }
+ cache->ents[h] = 0;
+ }
+ cache->entries = 0;
+ cache->referenced = 0;
+ cache->updated = False;
+}
+
+void
+XftFileCacheLoad (char *cache_file)
+{
+ XftFileCache *cache;
+ FILE *f;
+ char file[8192];
+ int id;
+ time_t time;
+ char name[8192];
+
+ f = fopen (cache_file, "r");
+ if (!f)
+ return;
+
+ cache = &_XftFileCache;
+
+ cache->updated = False;
+ while (_XftFileCacheReadString (f, file, sizeof (file)) &&
+ _XftFileCacheReadInt (f, &id) &&
+ _XftFileCacheReadTime (f, &time) &&
+ _XftFileCacheReadString (f, name, sizeof (name)))
+ {
+ (void) _XftFileCacheAdd (cache, file, id, time, name, False);
+ }
+ fclose (f);
+}
+
+Bool
+XftFileCacheUpdate (char *file, int id, char *name)
+{
+ XftFileCache *cache;
+ char *match;
+ struct stat statb;
+ Bool ret;
+
+ cache = &_XftFileCache;
+ match = file;
+
+ if (stat (file, &statb) < 0)
+ return False;
+ ret = _XftFileCacheAdd (cache, match, id,
+ statb.st_mtime, name, True);
+ if (ret)
+ cache->updated = True;
+ return ret;
+}
+
+static Bool
+_XftFileCacheWriteString (FILE *f, char *string)
+{
+ char c;
+
+ if (putc ('"', f) == EOF)
+ return False;
+ while ((c = *string++))
+ {
+ switch (c) {
+ case '"':
+ case '\\':
+ if (putc ('\\', f) == EOF)
+ return False;
+ /* fall through */
+ default:
+ if (putc (c, f) == EOF)
+ return False;
+ }
+ }
+ if (putc ('"', f) == EOF)
+ return False;
+ return True;
+}
+
+static Bool
+_XftFileCacheWriteUlong (FILE *f, unsigned long t)
+{
+ int pow;
+ unsigned long temp, digit;
+
+ temp = t;
+ pow = 1;
+ while (temp >= 10)
+ {
+ temp /= 10;
+ pow *= 10;
+ }
+ temp = t;
+ while (pow)
+ {
+ digit = temp / pow;
+ if (putc ((char) digit + '0', f) == EOF)
+ return False;
+ temp = temp - pow * digit;
+ pow = pow / 10;
+ }
+ return True;
+}
+
+static Bool
+_XftFileCacheWriteInt (FILE *f, int i)
+{
+ return _XftFileCacheWriteUlong (f, (unsigned long) i);
+}
+
+static Bool
+_XftFileCacheWriteTime (FILE *f, time_t t)
+{
+ return _XftFileCacheWriteUlong (f, (unsigned long) t);
+}
+
+Bool
+XftFileCacheSave (char *cache_file)
+{
+ XftFileCache *cache;
+ char *lck;
+ char *tmp;
+ FILE *f;
+ int h;
+ XftFileCacheEnt *c;
+
+ cache = &_XftFileCache;
+
+ if (!cache->updated && cache->referenced == cache->entries)
+ return True;
+
+ lck = malloc (strlen (cache_file)*2 + 4);
+ if (!lck)
+ goto bail0;
+ tmp = lck + strlen (cache_file) + 2;
+ strcpy (lck, cache_file);
+ strcat (lck, "L");
+ strcpy (tmp, cache_file);
+ strcat (tmp, "T");
+ if (link (lck, cache_file) < 0 && errno != ENOENT)
+ goto bail1;
+ if (access (tmp, F_OK) == 0)
+ goto bail2;
+ f = fopen (tmp, "w");
+ if (!f)
+ goto bail2;
+
+ for (h = 0; h < HASH_SIZE; h++)
+ {
+ for (c = cache->ents[h]; c; c = c->next)
+ {
+ if (!c->referenced)
+ continue;
+ if (!_XftFileCacheWriteString (f, c->file))
+ goto bail4;
+ if (putc (' ', f) == EOF)
+ goto bail4;
+ if (!_XftFileCacheWriteInt (f, c->id))
+ goto bail4;
+ if (putc (' ', f) == EOF)
+ goto bail4;
+ if (!_XftFileCacheWriteTime (f, c->time))
+ goto bail4;
+ if (putc (' ', f) == EOF)
+ goto bail4;
+ if (!_XftFileCacheWriteString (f, c->name))
+ goto bail4;
+ if (putc ('\n', f) == EOF)
+ goto bail4;
+ }
+ }
+
+ if (fclose (f) == EOF)
+ goto bail3;
+
+ if (rename (tmp, cache_file) < 0)
+ goto bail3;
+
+ unlink (lck);
+ cache->updated = False;
+ return True;
+
+bail4:
+ fclose (f);
+bail3:
+ unlink (tmp);
+bail2:
+ unlink (lck);
+bail1:
+ free (lck);
+bail0:
+ return False;
+}
+
+Bool
+XftFileCacheReadDir (XftFontSet *set, const char *cache_file)
+{
+ XftPattern *font;
+ FILE *f;
+ char *path;
+ char *base;
+ char file[8192];
+ int id;
+ char name[8192];
+ Bool ret = False;
+
+ if (_XftFontDebug () & XFT_DBG_CACHE)
+ {
+ printf ("XftFileCacheReadDir cache_file \"%s\"\n", cache_file);
+ }
+
+ f = fopen (cache_file, "r");
+ if (!f)
+ {
+ if (_XftFontDebug () & XFT_DBG_CACHE)
+ {
+ printf (" no cache file\n");
+ }
+ goto bail0;
+ }
+
+ base = strrchr (cache_file, '/');
+ if (!base)
+ goto bail1;
+ base++;
+ path = malloc (base - cache_file + 8192 + 1);
+ if (!path)
+ goto bail1;
+ memcpy (path, cache_file, base - cache_file);
+ base = path + (base - cache_file);
+
+ while (_XftFileCacheReadString (f, file, sizeof (file)) &&
+ _XftFileCacheReadInt (f, &id) &&
+ _XftFileCacheReadString (f, name, sizeof (name)))
+ {
+ font = XftNameParse (name);
+ if (font)
+ {
+ strcpy (base, file);
+ if (_XftFontDebug () & XFT_DBG_CACHEV)
+ {
+ printf (" dir cache file \"%s\"\n", file);
+ }
+ XftPatternAddString (font, XFT_FILE, path);
+ if (!XftFontSetAdd (set, font))
+ goto bail2;
+ }
+ }
+ if (_XftFontDebug () & XFT_DBG_CACHE)
+ {
+ printf (" cache loaded\n");
+ }
+
+ ret = True;
+bail2:
+ free (path);
+bail1:
+ fclose (f);
+bail0:
+ return ret;
+}
+
+Bool
+XftFileCacheWriteDir (XftFontSet *set, const char *cache_file)
+{
+ XftPattern *font;
+ FILE *f;
+ char name[8192];
+ char *file, *base;
+ int n;
+ int id;
+
+ if (_XftFontDebug () & XFT_DBG_CACHE)
+ printf ("XftFileCacheWriteDir cache_file \"%s\"\n", cache_file);
+
+ f = fopen (cache_file, "w");
+ if (!f)
+ {
+ if (_XftFontDebug () & XFT_DBG_CACHE)
+ printf (" can't create \"%s\"\n", cache_file);
+ goto bail0;
+ }
+ for (n = 0; n < set->nfont; n++)
+ {
+ font = set->fonts[n];
+ if (XftPatternGetString (font, XFT_FILE, 0, &file) != XftResultMatch)
+ goto bail1;
+ base = strrchr (file, '/');
+ if (base)
+ base = base + 1;
+ else
+ base = file;
+ if (XftPatternGetInteger (font, XFT_INDEX, 0, &id) != XftResultMatch)
+ goto bail1;
+ if (!XftNameUnparse (font, name, sizeof (name)))
+ goto bail1;
+ if (_XftFontDebug () & XFT_DBG_CACHEV)
+ printf (" write file \"%s\"\n", base);
+ if (!_XftFileCacheWriteString (f, base))
+ goto bail1;
+ if (putc (' ', f) == EOF)
+ goto bail1;
+ if (!_XftFileCacheWriteInt (f, id))
+ goto bail1;
+ if (putc (' ', f) == EOF)
+ goto bail1;
+ if (!_XftFileCacheWriteString (f, name))
+ goto bail1;
+ if (putc ('\n', f) == EOF)
+ goto bail1;
+ }
+ if (fclose (f) == EOF)
+ goto bail0;
+
+ if (_XftFontDebug () & XFT_DBG_CACHE)
+ printf (" cache written\n");
+ return True;
+
+bail1:
+ fclose (f);
+bail0:
+ unlink (cache_file);
+ return False;
+}
diff --git a/nx-X11/lib/Xft1/xftcfg.c b/nx-X11/lib/Xft1/xftcfg.c
new file mode 100644
index 000000000..b6e9d3a7c
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftcfg.c
@@ -0,0 +1,36 @@
+/*
+ * $XFree86: xc/lib/Xft/xftcfg.c,v 1.8 2001/01/02 02:46:51 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 <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "xftint.h"
+
+Bool
+XftConfigSubstitute (XftPattern *p)
+{
+ FcConfigSubstitute (0, p, FcMatchPattern);
+ FcConfigSubstitute (0, p, FcMatchFont);
+ return True;
+}
diff --git a/nx-X11/lib/Xft1/xftcolor.c b/nx-X11/lib/Xft1/xftcolor.c
new file mode 100644
index 000000000..9c81f50ca
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftcolor.c
@@ -0,0 +1,125 @@
+/*
+ * $XFree86: xc/lib/Xft/xftcolor.c,v 1.2 2001/05/16 17:20:06 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,
+ Visual *visual,
+ Colormap cmap,
+ 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,
+ 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/nx-X11/lib/Xft1/xftcore.c b/nx-X11/lib/Xft1/xftcore.c
new file mode 100644
index 000000000..331cbd7e3
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftcore.c
@@ -0,0 +1,247 @@
+/*
+ * $XFree86: xc/lib/Xft/xftcore.c,v 1.5 2000/12/20 00:28:44 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 <stdlib.h>
+#include "xftint.h"
+
+XChar2b *
+XftCoreConvert16 (XftChar16 *string,
+ int len,
+ XChar2b xcloc[XFT_CORE_N16LOCAL])
+{
+ XChar2b *xc;
+ int i;
+
+ if (len < XFT_CORE_N16LOCAL)
+ xc = xcloc;
+ else
+ xc = (XChar2b *) malloc (len * sizeof (XChar2b));
+ for (i = 0; i < len; i++)
+ {
+ xc[i].byte1 = string[i] & 0xff;
+ xc[i].byte2 = (string[i] >> 8) & 0xff;
+ }
+ return xc;
+}
+
+XChar2b *
+XftCoreConvert32 (XftChar32 *string,
+ int len,
+ XChar2b xcloc[XFT_CORE_N16LOCAL])
+{
+ XChar2b *xc;
+ int i;
+
+ if (len < XFT_CORE_N16LOCAL)
+ xc = xcloc;
+ else
+ xc = (XChar2b *) malloc (len * sizeof (XChar2b));
+ for (i = 0; i < len; i++)
+ {
+ xc[i].byte1 = string[i] & 0xff;
+ xc[i].byte2 = (string[i] >> 8) & 0xff;
+ }
+ return xc;
+}
+
+XChar2b *
+XftCoreConvertUtf8 (XftChar8 *string,
+ int len,
+ XChar2b xcloc[XFT_CORE_N16LOCAL],
+ int *nchar)
+{
+ XChar2b *xc;
+ XftChar32 c;
+ int i;
+ int n, width;
+ int clen;
+
+ if (!XftUtf8Len (string, len, &n, &width))
+ return 0;
+
+ if (n < XFT_CORE_N16LOCAL)
+ xc = xcloc;
+ else
+ xc = (XChar2b *) malloc (n * sizeof (XChar2b));
+ for (i = 0; i < n; i++)
+ {
+ clen = XftUtf8ToUcs4 (string, &c, len);
+ xc[i].byte1 = c & 0xff;
+ xc[i].byte2 = (c >> 8) & 0xff;
+ string += clen;
+ len -= clen;
+ }
+ *nchar = n;
+ return xc;
+}
+
+void
+XftCoreExtents8 (Display *dpy,
+ XFontStruct *fs,
+ XftChar8 *string,
+ int len,
+ XGlyphInfo *extents)
+{
+ int direction;
+ int ascent, descent;
+ XCharStruct overall;
+
+ XTextExtents (fs, (char *) string, len, &direction,
+ &ascent, &descent, &overall);
+ if (overall.lbearing < overall.rbearing)
+ {
+ extents->x = overall.lbearing;
+ extents->width = overall.rbearing - overall.lbearing;
+ }
+ else
+ {
+ extents->x = overall.rbearing;
+ extents->width = overall.lbearing - overall.rbearing;
+ }
+ extents->y = -overall.ascent;
+ extents->height = overall.ascent + overall.descent;
+ extents->xOff = overall.width;
+ extents->yOff = 0;
+}
+
+void
+XftCoreExtents16 (Display *dpy,
+ XFontStruct *fs,
+ XftChar16 *string,
+ int len,
+ XGlyphInfo *extents)
+{
+ int direction;
+ int ascent, descent;
+ XCharStruct overall;
+ XChar2b *xc, xcloc[XFT_CORE_N16LOCAL];
+
+ xc = XftCoreConvert16 (string, len, xcloc);
+ XTextExtents16 (fs, xc, len, &direction,
+ &ascent, &descent, &overall);
+ if (xc != xcloc)
+ free (xc);
+ if (overall.lbearing < overall.rbearing)
+ {
+ extents->x = overall.lbearing;
+ extents->width = overall.rbearing - overall.lbearing;
+ }
+ else
+ {
+ extents->x = overall.rbearing;
+ extents->width = overall.lbearing - overall.rbearing;
+ }
+ extents->y = -overall.ascent;
+ extents->height = overall.ascent + overall.descent;
+ extents->xOff = overall.width;
+ extents->yOff = 0;
+}
+
+void
+XftCoreExtents32 (Display *dpy,
+ XFontStruct *fs,
+ XftChar32 *string,
+ int len,
+ XGlyphInfo *extents)
+{
+ int direction;
+ int ascent, descent;
+ XCharStruct overall;
+ XChar2b *xc, xcloc[XFT_CORE_N16LOCAL];
+
+ xc = XftCoreConvert32 (string, len, xcloc);
+ XTextExtents16 (fs, xc, len, &direction,
+ &ascent, &descent, &overall);
+ if (xc != xcloc)
+ free (xc);
+ if (overall.lbearing < overall.rbearing)
+ {
+ extents->x = overall.lbearing;
+ extents->width = overall.rbearing - overall.lbearing;
+ }
+ else
+ {
+ extents->x = overall.rbearing;
+ extents->width = overall.lbearing - overall.rbearing;
+ }
+ extents->y = -overall.ascent;
+ extents->height = overall.ascent + overall.descent;
+ extents->xOff = overall.width;
+ extents->yOff = 0;
+}
+
+void
+XftCoreExtentsUtf8 (Display *dpy,
+ XFontStruct *fs,
+ XftChar8 *string,
+ int len,
+ XGlyphInfo *extents)
+{
+ int direction;
+ int ascent, descent;
+ XCharStruct overall;
+ XChar2b *xc, xcloc[XFT_CORE_N16LOCAL];
+ int n;
+
+ xc = XftCoreConvertUtf8 (string, len, xcloc, &n);
+ XTextExtents16 (fs, xc, n, &direction,
+ &ascent, &descent, &overall);
+ if (xc != xcloc)
+ free (xc);
+ if (overall.lbearing < overall.rbearing)
+ {
+ extents->x = overall.lbearing;
+ extents->width = overall.rbearing - overall.lbearing;
+ }
+ else
+ {
+ extents->x = overall.rbearing;
+ extents->width = overall.lbearing - overall.rbearing;
+ }
+ extents->y = -overall.ascent;
+ extents->height = overall.ascent + overall.descent;
+ extents->xOff = overall.width;
+ extents->yOff = 0;
+}
+
+Bool
+XftCoreGlyphExists (Display *dpy,
+ XFontStruct *fs,
+ XftChar32 glyph)
+{
+ int direction;
+ int ascent, descent;
+ XCharStruct overall;
+ XChar2b xc;
+
+ XftCoreConvert32 (&glyph, 1, &xc);
+ XTextExtents16 (fs, &xc, 1, &direction,
+ &ascent, &descent, &overall);
+ return (overall.lbearing != 0 ||
+ overall.rbearing != 0 ||
+ overall.width != 0 ||
+ overall.ascent != 0 ||
+ overall.descent != 0);
+}
+
diff --git a/nx-X11/lib/Xft1/xftdbg.c b/nx-X11/lib/Xft1/xftdbg.c
new file mode 100644
index 000000000..098fef74b
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftdbg.c
@@ -0,0 +1,43 @@
+/*
+ * $XFree86: xc/lib/Xft/xftdbg.c,v 1.3 2001/03/31 01:57:20 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"
+
+void
+XftFontSetPrint (XftFontSet *s)
+{
+ FcFontSetPrint (s);
+}
+
+void
+XftPatternPrint (XftPattern *p)
+{
+ FcPatternPrint (p);
+}
+
+void
+XftValuePrint (XftValue v)
+{
+ FcValuePrint (v);
+}
diff --git a/nx-X11/lib/Xft1/xftdir.c b/nx-X11/lib/Xft1/xftdir.c
new file mode 100644
index 000000000..88d89c902
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftdir.c
@@ -0,0 +1,42 @@
+/*
+ * $XFree86: xc/lib/Xft1/xftdir.c,v 1.2 2002/03/01 01:00:53 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 <sys/types.h>
+#include <dirent.h>
+#include <stdlib.h>
+#include <string.h>
+#include "xftint.h"
+
+Bool
+XftDirScan (XftFontSet *set, const char *dir, Bool force)
+{
+ return FcFalse;
+}
+
+Bool
+XftDirSave (XftFontSet *set, const char *dir)
+{
+ return FcFalse;
+}
+
diff --git a/nx-X11/lib/Xft1/xftdpy.c b/nx-X11/lib/Xft1/xftdpy.c
new file mode 100644
index 000000000..d28c5c88a
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftdpy.c
@@ -0,0 +1,436 @@
+/*
+ * $XFree86: xc/lib/Xft1/xftdpy.c,v 1.2tsi 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 <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <X11/Xlibint.h>
+#include "xftint.h"
+
+XftDisplayInfo *_XftDisplayInfo;
+
+static int
+_XftCloseDisplay (Display *dpy, XExtCodes *codes)
+{
+ XftDisplayInfo *info, **prev;
+
+ for (prev = &_XftDisplayInfo; (info = *prev); prev = &(*prev)->next)
+ if (info->codes == codes)
+ break;
+ if (!info)
+ return 0;
+ *prev = info->next;
+ if (info->defaults)
+ XftPatternDestroy (info->defaults);
+ if (info->coreFonts)
+ XftFontSetDestroy (info->coreFonts);
+ free (info);
+ return 0;
+}
+
+XftDisplayInfo *
+_XftDisplayInfoGet (Display *dpy)
+{
+ XftDisplayInfo *info, **prev;
+
+ 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;
+ }
+ }
+ 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->coreFonts = 0;
+ info->hasRender = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, DefaultScreen (dpy))) != 0;
+ info->glyphSets = 0;
+ if (_XftFontDebug () & 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");
+ }
+
+ info->next = _XftDisplayInfo;
+ _XftDisplayInfo = info;
+ return info;
+
+bail1:
+ free (info);
+bail0:
+ if (_XftFontDebug () & XFT_DBG_RENDER)
+ {
+ printf ("XftDisplayInfoGet failed to initialize, Xft unhappy\n");
+ }
+ return 0;
+}
+
+Bool
+XftDefaultHasRender (Display *dpy)
+{
+#ifdef FREETYPE2
+ XftDisplayInfo *info = _XftDisplayInfoGet (dpy);
+
+ if (!info)
+ return False;
+ return info->hasRender;
+#else
+ return False;
+#endif
+}
+
+Bool
+XftDefaultSet (Display *dpy, XftPattern *defaults)
+{
+ XftDisplayInfo *info = _XftDisplayInfoGet (dpy);
+
+ if (!info)
+ return False;
+ if (info->defaults)
+ XftPatternDestroy (info->defaults);
+ info->defaults = defaults;
+ return True;
+}
+
+int
+XftDefaultParseBool (char *v)
+{
+ char c0, c1;
+
+ c0 = *v;
+ if (isupper (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 (c1))
+ c1 = tolower (c1);
+ if (c1 == 'n')
+ return 1;
+ if (c1 == 'f')
+ return 0;
+ }
+ return -1;
+}
+
+static Bool
+_XftDefaultInitBool (Display *dpy, XftPattern *pat, char *option)
+{
+ char *v;
+ int i;
+
+ v = XGetDefault (dpy, "Xft", option);
+ if (v && (i = XftDefaultParseBool (v)) >= 0)
+ return XftPatternAddBool (pat, option, i != 0);
+ return True;
+}
+
+static Bool
+_XftDefaultInitDouble (Display *dpy, XftPattern *pat, char *option)
+{
+ char *v, *e;
+ double d;
+
+ v = XGetDefault (dpy, "Xft", option);
+ if (v)
+ {
+ d = strtod (v, &e);
+ if (e != v)
+ return XftPatternAddDouble (pat, option, d);
+ }
+ return True;
+}
+
+static Bool
+_XftDefaultInitInteger (Display *dpy, XftPattern *pat, char *option)
+{
+ char *v, *e;
+ int i;
+
+ v = XGetDefault (dpy, "Xft", option);
+ if (v)
+ {
+ if (XftNameConstant (v, &i))
+ return XftPatternAddInteger (pat, option, i);
+ i = strtol (v, &e, 0);
+ if (e != v)
+ return XftPatternAddInteger (pat, option, i);
+ }
+ return True;
+}
+
+static XftPattern *
+_XftDefaultInit (Display *dpy)
+{
+ XftPattern *pat;
+
+ pat = XftPatternCreate ();
+ if (!pat)
+ goto bail0;
+
+ if (!_XftDefaultInitBool (dpy, pat, XFT_CORE))
+ goto bail1;
+ if (!_XftDefaultInitDouble (dpy, pat, XFT_SCALE))
+ goto bail1;
+ if (!_XftDefaultInitDouble (dpy, pat, XFT_DPI))
+ goto bail1;
+ if (!_XftDefaultInitBool (dpy, pat, XFT_RENDER))
+ goto bail1;
+ if (!_XftDefaultInitInteger (dpy, pat, XFT_RGBA))
+ goto bail1;
+ if (!_XftDefaultInitBool (dpy, pat, XFT_ANTIALIAS))
+ goto bail1;
+ if (!_XftDefaultInitBool (dpy, pat, XFT_MINSPACE))
+ goto bail1;
+
+ return pat;
+
+bail1:
+ XftPatternDestroy (pat);
+bail0:
+ return 0;
+}
+
+static XftResult
+_XftDefaultGet (Display *dpy, const char *object, int screen, XftValue *v)
+{
+ XftDisplayInfo *info = _XftDisplayInfoGet (dpy);
+ XftResult r;
+
+ if (!info)
+ return XftResultNoMatch;
+
+ if (!info->defaults)
+ {
+ info->defaults = _XftDefaultInit (dpy);
+ if (!info->defaults)
+ return XftResultNoMatch;
+ }
+ r = XftPatternGet (info->defaults, object, screen, v);
+ if (r == XftResultNoId && screen > 0)
+ r = XftPatternGet (info->defaults, object, 0, v);
+ return r;
+}
+
+Bool
+XftDefaultGetBool (Display *dpy, const char *object, int screen, Bool def)
+{
+ XftResult r;
+ XftValue v;
+
+ r = _XftDefaultGet (dpy, object, screen, &v);
+ if (r != XftResultMatch || v.type != XftTypeBool)
+ return def;
+ return v.u.b;
+}
+
+int
+XftDefaultGetInteger (Display *dpy, const char *object, int screen, int def)
+{
+ XftResult r;
+ XftValue v;
+
+ r = _XftDefaultGet (dpy, object, screen, &v);
+ if (r != XftResultMatch || v.type != XftTypeInteger)
+ return def;
+ return v.u.i;
+}
+
+double
+XftDefaultGetDouble (Display *dpy, const char *object, int screen, double def)
+{
+ XftResult r;
+ XftValue v;
+
+ r = _XftDefaultGet (dpy, object, screen, &v);
+ if (r != XftResultMatch || v.type != XftTypeDouble)
+ return def;
+ return v.u.d;
+}
+
+XftFontSet *
+XftDisplayGetFontSet (Display *dpy)
+{
+ XftDisplayInfo *info = _XftDisplayInfoGet (dpy);
+
+ if (!info)
+ return 0;
+ if (!info->coreFonts)
+ {
+ info->coreFonts = XftFontSetCreate ();
+ if (info->coreFonts)
+ {
+ if (!XftCoreAddFonts (info->coreFonts, dpy,
+ XftDefaultGetBool (dpy, XFT_SCALABLE,
+ DefaultScreen (dpy),
+ False)))
+ {
+ XftFontSetDestroy (info->coreFonts);
+ info->coreFonts = 0;
+ }
+ }
+ }
+ return info->coreFonts;
+}
+
+void
+XftDefaultSubstitute (Display *dpy, int screen, XftPattern *pattern)
+{
+ XftValue v;
+ double size;
+ double scale;
+
+ if (XftPatternGet (pattern, XFT_STYLE, 0, &v) == XftResultNoMatch)
+ {
+ if (XftPatternGet (pattern, XFT_WEIGHT, 0, &v) == XftResultNoMatch )
+ {
+ XftPatternAddInteger (pattern, XFT_WEIGHT, XFT_WEIGHT_MEDIUM);
+ }
+ if (XftPatternGet (pattern, XFT_SLANT, 0, &v) == XftResultNoMatch)
+ {
+ XftPatternAddInteger (pattern, XFT_SLANT, XFT_SLANT_ROMAN);
+ }
+ }
+ if (XftPatternGet (pattern, XFT_ENCODING, 0, &v) == XftResultNoMatch)
+ XftPatternAddString (pattern, XFT_ENCODING, "iso8859-1");
+ if (XftPatternGet (pattern, XFT_RENDER, 0, &v) == XftResultNoMatch)
+ {
+ XftPatternAddBool (pattern, XFT_RENDER,
+ XftDefaultGetBool (dpy, XFT_RENDER, screen,
+ XftDefaultHasRender (dpy)));
+ }
+ if (XftPatternGet (pattern, XFT_CORE, 0, &v) == XftResultNoMatch)
+ {
+ XftPatternAddBool (pattern, XFT_CORE,
+ XftDefaultGetBool (dpy, XFT_CORE, screen,
+ !XftDefaultHasRender (dpy)));
+ }
+ if (XftPatternGet (pattern, XFT_ANTIALIAS, 0, &v) == XftResultNoMatch)
+ {
+ XftPatternAddBool (pattern, XFT_ANTIALIAS,
+ XftDefaultGetBool (dpy, XFT_ANTIALIAS, screen,
+ True));
+ }
+ if (XftPatternGet (pattern, XFT_RGBA, 0, &v) == XftResultNoMatch)
+ {
+ int subpixel = XFT_RGBA_NONE;
+#if RENDER_MAJOR > 0 || RENDER_MINOR >= 6
+ int render_order = XRenderQuerySubpixelOrder (dpy, screen);
+ switch (render_order) {
+ default:
+ case SubPixelUnknown: subpixel = XFT_RGBA_NONE; break;
+ case SubPixelHorizontalRGB: subpixel = XFT_RGBA_RGB; break;
+ case SubPixelHorizontalBGR: subpixel = XFT_RGBA_BGR; break;
+ case SubPixelVerticalRGB: subpixel = XFT_RGBA_VRGB; break;
+ case SubPixelVerticalBGR: subpixel = XFT_RGBA_VBGR; break;
+ case SubPixelNone: subpixel = XFT_RGBA_NONE; break;
+ }
+#endif
+ XftPatternAddInteger (pattern, XFT_RGBA,
+ XftDefaultGetInteger (dpy, XFT_RGBA, screen,
+ subpixel));
+ }
+ if (XftPatternGet (pattern, XFT_MINSPACE, 0, &v) == XftResultNoMatch)
+ {
+ XftPatternAddBool (pattern, XFT_MINSPACE,
+ XftDefaultGetBool (dpy, XFT_MINSPACE, screen,
+ False));
+ }
+ if (XftPatternGet (pattern, XFT_PIXEL_SIZE, 0, &v) == XftResultNoMatch)
+ {
+ double pixels, mm, dpi;
+
+ if (XftPatternGet (pattern, XFT_SIZE, 0, &v) != XftResultMatch)
+ {
+ size = 12.0;
+ XftPatternAddDouble (pattern, XFT_SIZE, size);
+ }
+ else
+ {
+ switch (v.type) {
+ case XftTypeInteger:
+ size = (double) v.u.i;
+ break;
+ case XftTypeDouble:
+ size = v.u.d;
+ break;
+ default:
+ size = 12.0;
+ break;
+ }
+ }
+ scale = XftDefaultGetDouble (dpy, XFT_SCALE, screen, 1.0);
+ size *= scale;
+ pixels = DisplayHeight (dpy, screen);
+ mm = DisplayHeightMM (dpy, screen);
+ dpi = (pixels * 25.4) / mm;
+ dpi = XftDefaultGetDouble (dpy, XFT_DPI, screen, dpi);
+ size = size * dpi / 72.0;
+ XftPatternAddDouble (pattern, XFT_PIXEL_SIZE, size);
+ }
+}
diff --git a/nx-X11/lib/Xft1/xftdraw.c b/nx-X11/lib/Xft1/xftdraw.c
new file mode 100644
index 000000000..f9c3b8b79
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftdraw.c
@@ -0,0 +1,482 @@
+/*
+ * $XFree86: xc/lib/Xft/xftdraw.c,v 1.15 2001/05/16 19:20:43 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "xftint.h"
+#include <X11/Xutil.h>
+
+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->visual = visual;
+ draw->colormap = colormap;
+ draw->core_set = False;
+ draw->render_set = False;
+ draw->render_able = False;
+ draw->clip = 0;
+ 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->visual = 0;
+ draw->colormap = 0;
+ draw->core_set = False;
+ draw->render_set = False;
+ draw->render_able = False;
+ draw->clip = 0;
+ return draw;
+}
+
+static XRenderPictFormat *
+_XftDrawFormat (XftDraw *draw)
+{
+ if (draw->visual == 0)
+ {
+ XRenderPictFormat pf;
+
+ pf.type = PictTypeDirect;
+ pf.depth = 1;
+ pf.direct.alpha = 0;
+ pf.direct.alphaMask = 1;
+ return XRenderFindFormat (draw->dpy,
+ (PictFormatType|
+ PictFormatDepth|
+ PictFormatAlpha|
+ PictFormatAlphaMask),
+ &pf,
+ 0);
+ }
+ else
+ return XRenderFindVisualFormat (draw->dpy, draw->visual);
+}
+
+static XRenderPictFormat *
+_XftDrawFgFormat (XftDraw *draw)
+{
+ XRenderPictFormat pf;
+
+ if (draw->visual == 0)
+ {
+ pf.type = PictTypeDirect;
+ pf.depth = 1;
+ pf.direct.alpha = 0;
+ pf.direct.alphaMask = 1;
+ return XRenderFindFormat (draw->dpy,
+ (PictFormatType|
+ PictFormatDepth|
+ PictFormatAlpha|
+ PictFormatAlphaMask),
+ &pf,
+ 0);
+ }
+ else
+ {
+ pf.type = PictTypeDirect;
+ pf.depth = 32;
+ pf.direct.redMask = 0xff;
+ pf.direct.greenMask = 0xff;
+ pf.direct.blueMask = 0xff;
+ pf.direct.alphaMask = 0xff;
+ return XRenderFindFormat (draw->dpy,
+ (PictFormatType|
+ PictFormatDepth|
+ PictFormatRedMask|
+ PictFormatGreenMask|
+ PictFormatBlueMask|
+ PictFormatAlphaMask),
+ &pf,
+ 0);
+ }
+}
+
+void
+XftDrawChange (XftDraw *draw,
+ Drawable drawable)
+{
+ draw->drawable = drawable;
+ if (draw->render_able)
+ {
+ XRenderPictFormat *format;
+
+ XRenderFreePicture (draw->dpy, draw->render.pict);
+ format = XRenderFindVisualFormat (draw->dpy, draw->visual);
+ draw->render.pict = XRenderCreatePicture (draw->dpy, draw->drawable,
+ format, 0, 0);
+ }
+}
+
+void
+XftDrawDestroy (XftDraw *draw)
+{
+ int n;
+
+ if (draw->render_able)
+ {
+ XRenderFreePicture (draw->dpy, draw->render.pict);
+ for (n = 0; n < XFT_DRAW_N_SRC; n++)
+ XRenderFreePicture (draw->dpy, draw->render.src[n].pict);
+ }
+ if (draw->core_set)
+ XFreeGC (draw->dpy, draw->core.draw_gc);
+ if (draw->clip)
+ XDestroyRegion (draw->clip);
+ free (draw);
+}
+
+Bool
+XftDrawRenderPrepare (XftDraw *draw,
+ XftColor *color,
+ XftFont *font,
+ int src)
+{
+ if (!draw->render_set)
+ {
+ XRenderPictFormat *format;
+ XRenderPictFormat *pix_format;
+ XRenderPictureAttributes pa;
+ int n;
+ Pixmap pix;
+
+ draw->render_set = True;
+ draw->render_able = False;
+ format = _XftDrawFormat (draw);
+ pix_format = _XftDrawFgFormat (draw);
+ if (format && pix_format)
+ {
+ draw->render_able = True;
+
+ draw->render.pict = XRenderCreatePicture (draw->dpy, draw->drawable,
+ format, 0, 0);
+ for (n = 0; n < XFT_DRAW_N_SRC; n++)
+ {
+ pix = XCreatePixmap (draw->dpy, draw->drawable,
+ 1, 1, pix_format->depth);
+ pa.repeat = True;
+ draw->render.src[n].pict = XRenderCreatePicture (draw->dpy,
+ pix,
+ pix_format,
+ CPRepeat, &pa);
+ XFreePixmap (draw->dpy, pix);
+
+ draw->render.src[n].color = color->color;
+ XRenderFillRectangle (draw->dpy, PictOpSrc,
+ draw->render.src[n].pict,
+ &color->color, 0, 0, 1, 1);
+ }
+ if (draw->clip)
+ XRenderSetPictureClipRegion (draw->dpy, draw->render.pict,
+ draw->clip);
+ }
+ }
+ if (!draw->render_able)
+ return False;
+ if (memcmp (&color->color, &draw->render.src[src].color,
+ sizeof (XRenderColor)))
+ {
+ if (_XftFontDebug () & XFT_DBG_DRAW)
+ {
+ printf ("Switching to color %04x,%04x,%04x,%04x\n",
+ color->color.alpha,
+ color->color.red,
+ color->color.green,
+ color->color.blue);
+ }
+ XRenderFillRectangle (draw->dpy, PictOpSrc,
+ draw->render.src[src].pict,
+ &color->color, 0, 0, 1, 1);
+ draw->render.src[src].color = color->color;
+ }
+ return True;
+}
+
+Bool
+XftDrawCorePrepare (XftDraw *draw,
+ XftColor *color,
+ XftFont *font)
+{
+
+ if (!draw->core_set)
+ {
+ XGCValues gcv;
+ unsigned long mask;
+ draw->core_set = True;
+
+ draw->core.fg = color->pixel;
+ gcv.foreground = draw->core.fg;
+ mask = GCForeground;
+ if (font)
+ {
+ draw->core.font = font->u.core.font->fid;
+ gcv.font = draw->core.font;
+ mask |= GCFont;
+ }
+ draw->core.draw_gc = XCreateGC (draw->dpy, draw->drawable,
+ mask, &gcv);
+ if (draw->clip)
+ XSetRegion (draw->dpy, draw->core.draw_gc, draw->clip);
+ }
+ if (draw->core.fg != color->pixel)
+ {
+ draw->core.fg = color->pixel;
+ XSetForeground (draw->dpy, draw->core.draw_gc, draw->core.fg);
+ }
+ if (font && draw->core.font != font->u.core.font->fid)
+ {
+ draw->core.font = font->u.core.font->fid;
+ XSetFont (draw->dpy, draw->core.draw_gc, draw->core.font);
+ }
+ return True;
+}
+
+void
+XftDrawString8 (XftDraw *draw,
+ XftColor *color,
+ XftFont *font,
+ int x,
+ int y,
+ XftChar8 *string,
+ int len)
+{
+ if (_XftFontDebug () & XFT_DBG_DRAW)
+ {
+ printf ("DrawString \"%*.*s\"\n", len, len, string);
+ }
+ if (font->core)
+ {
+ XftDrawCorePrepare (draw, color, font);
+ XDrawString (draw->dpy, draw->drawable, draw->core.draw_gc, x, y,
+ (char *) string, len);
+ }
+#ifdef FREETYPE2
+ else if (XftDrawRenderPrepare (draw, color, font, XFT_DRAW_SRC_TEXT))
+ {
+ XftRenderString8 (draw->dpy,
+ draw->render.src[XFT_DRAW_SRC_TEXT].pict,
+ font->u.ft.font,
+ draw->render.pict, 0, 0, x, y, string, len);
+ }
+#endif
+}
+
+#define N16LOCAL 256
+
+void
+XftDrawString16 (XftDraw *draw,
+ XftColor *color,
+ XftFont *font,
+ int x,
+ int y,
+ XftChar16 *string,
+ int len)
+{
+ if (font->core)
+ {
+ XChar2b *xc;
+ XChar2b xcloc[XFT_CORE_N16LOCAL];
+
+ XftDrawCorePrepare (draw, color, font);
+ xc = XftCoreConvert16 (string, len, xcloc);
+ XDrawString16 (draw->dpy, draw->drawable, draw->core.draw_gc, x, y,
+ xc, len);
+ if (xc != xcloc)
+ free (xc);
+ }
+#ifdef FREETYPE2
+ else if (XftDrawRenderPrepare (draw, color, font, XFT_DRAW_SRC_TEXT))
+ {
+ XftRenderString16 (draw->dpy,
+ draw->render.src[XFT_DRAW_SRC_TEXT].pict,
+ font->u.ft.font,
+ draw->render.pict, 0, 0, x, y, string, len);
+ }
+#endif
+}
+
+void
+XftDrawString32 (XftDraw *draw,
+ XftColor *color,
+ XftFont *font,
+ int x,
+ int y,
+ XftChar32 *string,
+ int len)
+{
+ if (font->core)
+ {
+ XChar2b *xc;
+ XChar2b xcloc[XFT_CORE_N16LOCAL];
+
+ XftDrawCorePrepare (draw, color, font);
+ xc = XftCoreConvert32 (string, len, xcloc);
+ XDrawString16 (draw->dpy, draw->drawable, draw->core.draw_gc, x, y,
+ xc, len);
+ if (xc != xcloc)
+ free (xc);
+ }
+#ifdef FREETYPE2
+ else if (XftDrawRenderPrepare (draw, color, font, XFT_DRAW_SRC_TEXT))
+ {
+ XftRenderString32 (draw->dpy,
+ draw->render.src[XFT_DRAW_SRC_TEXT].pict,
+ font->u.ft.font,
+ draw->render.pict, 0, 0, x, y, string, len);
+ }
+#endif
+}
+
+void
+XftDrawStringUtf8 (XftDraw *draw,
+ XftColor *color,
+ XftFont *font,
+ int x,
+ int y,
+ XftChar8 *string,
+ int len)
+{
+ if (font->core)
+ {
+ XChar2b *xc;
+ XChar2b xcloc[XFT_CORE_N16LOCAL];
+ int n;
+
+ XftDrawCorePrepare (draw, color, font);
+ xc = XftCoreConvertUtf8 (string, len, xcloc, &n);
+ if (xc)
+ {
+ XDrawString16 (draw->dpy, draw->drawable, draw->core.draw_gc, x, y,
+ xc, n);
+ }
+ if (xc != xcloc)
+ free (xc);
+ }
+#ifdef FREETYPE2
+ else if (XftDrawRenderPrepare (draw, color, font, XFT_DRAW_SRC_TEXT))
+ {
+ XftRenderStringUtf8 (draw->dpy,
+ draw->render.src[XFT_DRAW_SRC_TEXT].pict,
+ font->u.ft.font,
+ draw->render.pict, 0, 0, x, y, string, len);
+ }
+#endif
+}
+
+
+void
+XftDrawRect (XftDraw *draw,
+ XftColor *color,
+ int x,
+ int y,
+ unsigned int width,
+ unsigned int height)
+{
+ if (XftDrawRenderPrepare (draw, color, 0, XFT_DRAW_SRC_RECT))
+ {
+ XRenderFillRectangle (draw->dpy, PictOpOver, draw->render.pict,
+ &color->color, x, y, width, height);
+ }
+ else
+ {
+ XftDrawCorePrepare (draw, color, 0);
+ XFillRectangle (draw->dpy, draw->drawable, draw->core.draw_gc,
+ x, y, width, height);
+ }
+}
+
+Bool
+XftDrawSetClip (XftDraw *draw,
+ Region r)
+{
+ Region n = 0;
+
+ if (!r && !draw->clip)
+ return True;
+
+ if (r)
+ {
+ n = XCreateRegion ();
+ if (n)
+ {
+ if (!XUnionRegion (n, r, n))
+ {
+ XDestroyRegion (n);
+ return False;
+ }
+ }
+ }
+ if (draw->clip)
+ {
+ XDestroyRegion (draw->clip);
+ }
+ draw->clip = n;
+ if (draw->render_able)
+ {
+ XRenderPictureAttributes pa;
+ if (n)
+ {
+ XRenderSetPictureClipRegion (draw->dpy, draw->render.pict, n);
+ }
+ else
+ {
+ pa.clip_mask = None;
+ XRenderChangePicture (draw->dpy, draw->render.pict,
+ CPClipMask, &pa);
+ }
+ }
+ if (draw->core_set)
+ {
+ XGCValues gv;
+
+ if (n)
+ XSetRegion (draw->dpy, draw->core.draw_gc, n);
+ else
+ {
+ gv.clip_mask = None;
+ XChangeGC (draw->dpy, draw->core.draw_gc,
+ GCClipMask, &gv);
+ }
+ }
+ return True;
+}
diff --git a/nx-X11/lib/Xft1/xftextent.c b/nx-X11/lib/Xft1/xftextent.c
new file mode 100644
index 000000000..8a6cf620a
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftextent.c
@@ -0,0 +1,190 @@
+/*
+ * $XFree86: xc/lib/Xft/xftextent.c,v 1.6 2001/04/01 14:00:01 tsi 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 <stdlib.h>
+#include <string.h>
+#include "xftint.h"
+
+void
+XftTextExtents8 (Display *dpy,
+ XftFont *font,
+ XftChar8 *string,
+ int len,
+ XGlyphInfo *extents)
+{
+ if (font->core)
+ {
+ XftCoreExtents8 (dpy, font->u.core.font, string, len, extents);
+ }
+#ifdef FREETYPE2
+ else
+ {
+ XftRenderExtents8 (dpy, font->u.ft.font, string, len, extents);
+ }
+#endif
+}
+
+void
+XftTextExtents16 (Display *dpy,
+ XftFont *font,
+ XftChar16 *string,
+ int len,
+ XGlyphInfo *extents)
+{
+ if (font->core)
+ {
+ XftCoreExtents16 (dpy, font->u.core.font, string, len, extents);
+ }
+#ifdef FREETYPE2
+ else
+ {
+ XftRenderExtents16 (dpy, font->u.ft.font, string, len, extents);
+ }
+#endif
+}
+
+void
+XftTextExtents32 (Display *dpy,
+ XftFont *font,
+ XftChar32 *string,
+ int len,
+ XGlyphInfo *extents)
+{
+ if (font->core)
+ {
+ XftCoreExtents32 (dpy, font->u.core.font, string, len, extents);
+ }
+#ifdef FREETYPE2
+ else
+ {
+ XftRenderExtents32 (dpy, font->u.ft.font, string, len, extents);
+ }
+#endif
+}
+
+void
+XftTextExtentsUtf8 (Display *dpy,
+ XftFont *font,
+ XftChar8 *string,
+ int len,
+ XGlyphInfo *extents)
+{
+ XftChar8 *src;
+ XftChar32 c;
+ XftChar32 lbuf[4096];
+ XftChar32 *dst;
+ XftChar8 *dst8;
+ XftChar16 *dst16;
+ XftChar32 *dst32;
+ int rlen, clen;
+ int width = 1;
+ int n;
+
+ /* compute needed width */
+ src = string;
+ rlen = len;
+ n = 0;
+ while (rlen)
+ {
+ clen = XftUtf8ToUcs4 (src, &c, rlen);
+ if (clen <= 0) /* malformed UTF8 string */
+ {
+ memset (extents, 0, sizeof (XGlyphInfo));
+ return;
+ }
+ if (c >= 0x10000)
+ width = 4;
+ else if (c >= 0x100)
+ {
+ if (width == 1)
+ width = 2;
+ }
+ src += clen;
+ rlen -= clen;
+ n++;
+ }
+ dst = lbuf;
+ if (n * width > sizeof (lbuf))
+ {
+ dst = (XftChar32 *) malloc (n * width);
+ if (!dst)
+ {
+ memset (extents, 0, sizeof (XGlyphInfo));
+ return;
+ }
+ }
+
+ switch (width) {
+ case 4:
+ src = string;
+ rlen = len;
+ dst32 = dst;
+ while (rlen)
+ {
+ clen = XftUtf8ToUcs4 (src, &c, rlen);
+ if (clen <= 0) /* malformed UTF8 string */
+ return;
+ *dst32++ = c;
+ src += clen;
+ rlen -= clen;
+ }
+ dst32 = dst;
+ XftTextExtents32 (dpy, font, dst32, n, extents);
+ break;
+ case 2:
+ src = string;
+ rlen = len;
+ dst16 = (XftChar16 *) dst;
+ while (rlen)
+ {
+ clen = XftUtf8ToUcs4 (src, &c, rlen);
+ if (clen <= 0) /* malformed UTF8 string */
+ return;
+ *dst16++ = c;
+ src += clen;
+ rlen -= clen;
+ }
+ dst16 = (XftChar16 *) dst;
+ XftTextExtents16 (dpy, font, dst16, n, extents);
+ break;
+ case 1:
+ src = string;
+ rlen = len;
+ dst8 = (XftChar8 *) dst;
+ while (rlen)
+ {
+ clen = XftUtf8ToUcs4 (src, &c, rlen);
+ if (clen <= 0) /* malformed UTF8 string */
+ return;
+ *dst8++ = c;
+ src += clen;
+ rlen -= clen;
+ }
+ dst8 = (XftChar8 *) dst;
+ XftTextExtents8 (dpy, font, dst8, n, extents);
+ break;
+ }
+ if (dst != lbuf)
+ free (dst);
+}
diff --git a/nx-X11/lib/Xft1/xftfont.c b/nx-X11/lib/Xft1/xftfont.c
new file mode 100644
index 000000000..ab393af81
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftfont.c
@@ -0,0 +1,327 @@
+/*
+ * $XFree86: xc/lib/Xft/xftfont.c,v 1.8 2000/12/20 00:20:48 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 <stdio.h>
+#include <stdlib.h>
+#include "xftint.h"
+
+XftPattern *
+XftFontMatch (Display *dpy, int screen, XftPattern *pattern, XftResult *result)
+{
+ XftPattern *new;
+ XftPattern *match;
+ XftFontSet *sets[2];
+ int nsets;
+#ifdef FREETYPE2
+ Bool render, core;
+#endif
+
+ if (!XftInit (0))
+ return 0;
+
+ new = XftPatternDuplicate (pattern);
+ if (!new)
+ return 0;
+
+ if (_XftFontDebug () & XFT_DBG_OPENV)
+ {
+ printf ("XftFontMatch pattern ");
+ XftPatternPrint (new);
+ }
+ XftConfigSubstitute (new);
+ if (_XftFontDebug () & XFT_DBG_OPENV)
+ {
+ printf ("XftFontMatch after XftConfig substitutions ");
+ XftPatternPrint (new);
+ }
+ XftDefaultSubstitute (dpy, screen, new);
+ if (_XftFontDebug () & XFT_DBG_OPENV)
+ {
+ printf ("XftFontMatch after X resource substitutions ");
+ XftPatternPrint (new);
+ }
+ nsets = 0;
+
+#ifdef FREETYPE2
+ render = False;
+ core = True;
+ (void) XftPatternGetBool (new, XFT_RENDER, 0, &render);
+ (void) XftPatternGetBool (new, XFT_CORE, 0, &core);
+ if (_XftFontDebug () & XFT_DBG_OPENV)
+ {
+ printf ("XftFontMatch: use core fonts \"%s\", use render fonts \"%s\"\n",
+ core ? "True" : "False", render ? "True" : "False");
+ }
+
+ if (render)
+ {
+ if (XftInitFtLibrary())
+ {
+ sets[nsets] = _XftFontSet;
+ if (sets[nsets])
+ nsets++;
+ }
+ }
+ if (core)
+#endif
+ {
+ sets[nsets] = XftDisplayGetFontSet (dpy);
+ if (sets[nsets])
+ nsets++;
+ }
+
+ match = XftFontSetMatch (sets, nsets, new, result);
+ XftPatternDestroy (new);
+ return match;
+}
+
+XftFont *
+XftFontOpenPattern (Display *dpy, XftPattern *pattern)
+{
+ Bool core = True;
+ XFontStruct *xfs = 0;
+ XftFont *font;
+#ifdef FREETYPE2
+ XftFontStruct *fs = 0;
+
+ if (XftPatternGetBool (pattern, XFT_CORE, 0, &core) != XftResultMatch)
+ return 0;
+ if (core)
+#endif
+ {
+ xfs = XftCoreOpen (dpy, pattern);
+ if (!xfs) return 0;
+ }
+#ifdef FREETYPE2
+ else
+ {
+ fs = XftFreeTypeOpen (dpy, pattern);
+ if (!fs) return 0;
+ }
+#endif
+ font = (XftFont *) malloc (sizeof (XftFont));
+ font->core = core;
+ font->pattern = pattern;
+#ifdef FREETYPE2
+ if (core)
+#endif
+ {
+ font->u.core.font = xfs;
+ font->ascent = xfs->ascent;
+ font->descent = xfs->descent;
+ font->height = xfs->ascent + xfs->descent;
+ font->max_advance_width = xfs->max_bounds.width;
+ }
+#ifdef FREETYPE2
+ else
+ {
+ font->u.ft.font = fs;
+ font->ascent = fs->ascent;
+ font->descent = fs->descent;
+ font->height = fs->height;
+ font->max_advance_width = fs->max_advance_width;
+ }
+#endif
+ return font;
+}
+
+int
+_XftFontDebug (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;
+}
+
+XftFont *
+XftFontOpen (Display *dpy, int screen, ...)
+{
+ va_list va;
+ XftPattern *pat;
+ XftPattern *match;
+ XftResult result;
+ XftFont *font;
+
+ va_start (va, screen);
+ pat = XftPatternVaBuild (0, va);
+ va_end (va);
+ if (!pat)
+ {
+ if (_XftFontDebug () & XFT_DBG_OPEN)
+ printf ("XftFontOpen: Invalid pattern argument\n");
+ return 0;
+ }
+ match = XftFontMatch (dpy, screen, pat, &result);
+ if (_XftFontDebug () & XFT_DBG_OPEN)
+ {
+ printf ("Pattern ");
+ XftPatternPrint (pat);
+ if (match)
+ {
+ printf ("Match ");
+ XftPatternPrint (match);
+ }
+ else
+ printf ("No Match\n");
+ }
+ XftPatternDestroy (pat);
+ if (!match)
+ return 0;
+
+ font = XftFontOpenPattern (dpy, match);
+ if (!font)
+ {
+ if (_XftFontDebug () & XFT_DBG_OPEN)
+ printf ("No Font\n");
+ XftPatternDestroy (match);
+ }
+
+ return font;
+}
+
+XftFont *
+XftFontOpenName (Display *dpy, int screen, const char *name)
+{
+ XftPattern *pat;
+ XftPattern *match;
+ XftResult result;
+ XftFont *font;
+
+ pat = XftNameParse (name);
+ if (_XftFontDebug () & XFT_DBG_OPEN)
+ {
+ printf ("XftFontOpenName \"%s\": ", name);
+ if (pat)
+ XftPatternPrint (pat);
+ else
+ printf ("Invalid name\n");
+ }
+
+ if (!pat)
+ return 0;
+ match = XftFontMatch (dpy, screen, pat, &result);
+ if (_XftFontDebug () & XFT_DBG_OPEN)
+ {
+ if (match)
+ {
+ printf ("Match ");
+ XftPatternPrint (match);
+ }
+ else
+ printf ("No Match\n");
+ }
+ XftPatternDestroy (pat);
+ if (!match)
+ return 0;
+
+ font = XftFontOpenPattern (dpy, match);
+ if (!font)
+ XftPatternDestroy (match);
+
+ return font;
+}
+
+XftFont *
+XftFontOpenXlfd (Display *dpy, int screen, const char *xlfd)
+{
+ XftPattern *pat;
+ XftPattern *match;
+ XftResult result;
+ XftFont *font;
+
+ pat = XftXlfdParse (xlfd, False, False);
+ if (_XftFontDebug () & XFT_DBG_OPEN)
+ {
+ printf ("XftFontOpenXlfd \"%s\": ", xlfd);
+ if (pat)
+ printf ("Invalid xlfd\n");
+ else
+ XftPatternPrint (pat);
+ }
+
+ if (!pat)
+ return 0;
+ match = XftFontMatch (dpy, screen, pat, &result);
+ if (_XftFontDebug () & XFT_DBG_OPEN)
+ {
+ if (match)
+ {
+ printf ("Match ");
+ XftPatternPrint (match);
+ }
+ else
+ printf ("No Match\n");
+ }
+ XftPatternDestroy (pat);
+ if (!match)
+ return 0;
+
+ font = XftFontOpenPattern (dpy, match);
+ if (!font)
+ XftPatternDestroy (match);
+
+ return font;
+}
+
+void
+XftFontClose (Display *dpy, XftFont *font)
+{
+ if (font->core)
+ XftCoreClose (dpy, font->u.core.font);
+#ifdef FREETYPE2
+ else
+ XftFreeTypeClose (dpy, font->u.ft.font);
+#endif
+ if (font->pattern)
+ XftPatternDestroy (font->pattern);
+ free (font);
+}
+
+Bool
+XftGlyphExists (Display *dpy, XftFont *font, XftChar32 glyph)
+{
+ if (font->core)
+ return XftCoreGlyphExists (dpy, font->u.core.font, glyph);
+ else
+#ifdef FREETYPE2
+ return XftFreeTypeGlyphExists (dpy, font->u.ft.font, glyph);
+#else
+ return False;
+#endif
+}
diff --git a/nx-X11/lib/Xft1/xftfreetype.c b/nx-X11/lib/Xft1/xftfreetype.c
new file mode 100644
index 000000000..1021c95bf
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftfreetype.c
@@ -0,0 +1,678 @@
+/*
+ * $XFree86: xc/lib/Xft1/xftfreetype.c,v 1.5 2002/08/12 22:17:49 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 <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "xftint.h"
+
+FT_Library _XftFTlibrary;
+
+typedef struct _XftFtEncoding {
+ const char *name;
+ FT_Encoding encoding;
+} XftFtEncoding;
+
+static XftFtEncoding xftFtEncoding[] = {
+ { "iso10646-1", ft_encoding_unicode, },
+ { "iso8859-1", ft_encoding_unicode, },
+ { "apple-roman", ft_encoding_apple_roman },
+ { "adobe-fontspecific", ft_encoding_symbol, },
+ { "glyphs-fontspecific",ft_encoding_none, },
+};
+
+#define NUM_FT_ENCODINGS (sizeof xftFtEncoding / sizeof xftFtEncoding[0])
+
+#define FT_Matrix_Equal(a,b) ((a)->xx == (b)->xx && \
+ (a)->yy == (b)->yy && \
+ (a)->xy == (b)->xy && \
+ (a)->yx == (b)->yx)
+
+XftPattern *
+XftFreeTypeQuery (const char *file, int id, int *count)
+{
+ FT_Face face;
+ XftPattern *pat;
+ int slant;
+ int weight;
+ int i, j;
+
+ if (FT_New_Face (_XftFTlibrary, file, id, &face))
+ return 0;
+
+ *count = face->num_faces;
+
+ pat = XftPatternCreate ();
+ if (!pat)
+ goto bail0;
+
+
+ if (!XftPatternAddBool (pat, XFT_CORE, False))
+ goto bail1;
+
+ if (!XftPatternAddBool (pat, XFT_OUTLINE,
+ (face->face_flags & FT_FACE_FLAG_SCALABLE) != 0))
+ goto bail1;
+
+ if (!XftPatternAddBool (pat, XFT_SCALABLE,
+ (face->face_flags & FT_FACE_FLAG_SCALABLE) != 0))
+ goto bail1;
+
+
+ slant = XFT_SLANT_ROMAN;
+ if (face->style_flags & FT_STYLE_FLAG_ITALIC)
+ slant = XFT_SLANT_ITALIC;
+
+ if (!XftPatternAddInteger (pat, XFT_SLANT, slant))
+ goto bail1;
+
+ weight = XFT_WEIGHT_MEDIUM;
+ if (face->style_flags & FT_STYLE_FLAG_BOLD)
+ weight = XFT_WEIGHT_BOLD;
+
+ if (!XftPatternAddInteger (pat, XFT_WEIGHT, weight))
+ goto bail1;
+
+ if (!XftPatternAddString (pat, XFT_FAMILY, face->family_name))
+ goto bail1;
+
+ if (!XftPatternAddString (pat, XFT_STYLE, face->style_name))
+ goto bail1;
+
+ if (!XftPatternAddString (pat, XFT_FILE, file))
+ goto bail1;
+
+ if (!XftPatternAddInteger (pat, XFT_INDEX, id))
+ goto bail1;
+
+#if 0
+ if ((face->face_flags & FT_FACE_FLAG_FIXED_WIDTH) != 0)
+ if (!XftPatternAddInteger (pat, XFT_SPACING, XFT_MONO))
+ goto bail1;
+#endif
+
+ if (!(face->face_flags & FT_FACE_FLAG_SCALABLE))
+ {
+ for (i = 0; i < face->num_fixed_sizes; i++)
+ if (!XftPatternAddDouble (pat, XFT_PIXEL_SIZE,
+ (double) face->available_sizes[i].height))
+ goto bail1;
+ }
+
+ for (i = 0; i < face->num_charmaps; i++)
+ {
+#if 0
+ printf ("face %s encoding %d %c%c%c%c\n",
+ face->family_name, i,
+ face->charmaps[i]->encoding >> 24,
+ face->charmaps[i]->encoding >> 16,
+ face->charmaps[i]->encoding >> 8,
+ face->charmaps[i]->encoding >> 0);
+#endif
+ for (j = 0; j < NUM_FT_ENCODINGS; j++)
+ {
+ if (face->charmaps[i]->encoding == xftFtEncoding[j].encoding)
+ {
+ if (!XftPatternAddString (pat, XFT_ENCODING,
+ xftFtEncoding[j].name))
+ goto bail1;
+ }
+ }
+ }
+
+ if (!XftPatternAddString (pat, XFT_ENCODING,
+ "glyphs-fontspecific"))
+ goto bail1;
+
+
+ FT_Done_Face (face);
+ return pat;
+
+bail1:
+ XftPatternDestroy (pat);
+bail0:
+ FT_Done_Face (face);
+ return 0;
+}
+
+/*
+ * List of all open files (each face in a file is managed separately)
+ */
+typedef struct _XftFtFile {
+ struct _XftFtFile *next;
+ int ref;
+
+ char *file;
+ int id;
+
+ FT_Face face;
+ FT_F26Dot6 size;
+ FT_Matrix matrix;
+ int charmap;
+} XftFtFile;
+
+static XftFtFile *_XftFtFiles;
+
+static XftFtFile *
+_XftFreeTypeOpenFile (char *file, int id)
+{
+ XftFtFile *f;
+ FT_Face face;
+
+ for (f = _XftFtFiles; f; f = f->next)
+ {
+ if (!strcmp (f->file, file) && f->id == id)
+ {
+ ++f->ref;
+ if (_XftFontDebug () & XFT_DBG_REF)
+ printf ("FontFile %s/%d matches existing (%d)\n",
+ file, id, f->ref);
+ return f;
+ }
+ }
+ if (FT_New_Face (_XftFTlibrary, file, id, &face))
+ return 0;
+
+ f = malloc (sizeof (XftFtFile) + strlen (file) + 1);
+ if (!f)
+ return 0;
+
+ if (_XftFontDebug () & 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, file);
+ f->id = id;
+
+ f->face = face;
+ f->size = 0;
+ f->charmap = -1;
+ f->matrix.xx = 0x10000;
+ f->matrix.xy = 0x0;
+ f->matrix.yy = 0x10000;
+ f->matrix.yx = 0x0;
+ return f;
+}
+
+Bool
+XftFreeTypeSetFace (FT_Face face, FT_F26Dot6 size, int charmap, FT_Matrix *matrix)
+{
+ XftFtFile *f, **prev;
+
+ for (prev = &_XftFtFiles; (f = *prev); prev = &f->next)
+ {
+ if (f->face == face)
+ {
+ /* LRU */
+ if (prev != &_XftFtFiles)
+ {
+ *prev = f->next;
+ f->next = _XftFtFiles;
+ _XftFtFiles = f;
+ }
+ if (f->size != size)
+ {
+ if (_XftFontDebug() & XFT_DBG_GLYPH)
+ printf ("Set face size to %d (%d)\n",
+ (int) (size >> 6), (int) size);
+ if (FT_Set_Char_Size (face, size, size, 0, 0))
+ return False;
+ f->size = size;
+ }
+ if (f->charmap != charmap && charmap != -1)
+ {
+ if (_XftFontDebug() & XFT_DBG_GLYPH)
+ printf ("Set face charmap to %d\n", charmap);
+ if (FT_Set_Charmap (face, face->charmaps[charmap]))
+ return False;
+ f->charmap = charmap;
+ }
+ if (!FT_Matrix_Equal (&f->matrix, matrix))
+ {
+ if (_XftFontDebug() & 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;
+ }
+ break;
+ }
+ }
+ return True;
+}
+
+static void
+_XftFreeTypeCloseFile (XftFtFile *f)
+{
+ XftFtFile **prev;
+
+ if (--f->ref != 0)
+ return;
+ for (prev = &_XftFtFiles; *prev; prev = &(*prev)->next)
+ {
+ if (*prev == f)
+ {
+ *prev = f->next;
+ break;
+ }
+ }
+ FT_Done_Face (f->face);
+ free (f);
+}
+
+/*
+ * Cache of all glyphsets
+ */
+typedef struct _XftFtGlyphSet {
+ struct _XftFtGlyphSet *next;
+ int ref;
+
+ XftFtFile *file;
+ Bool minspace;
+ int char_width;
+
+ XftFontStruct font;
+} XftFtGlyphSet;
+
+XftFontStruct *
+XftFreeTypeOpen (Display *dpy, XftPattern *pattern)
+{
+ XftDisplayInfo *info = _XftDisplayInfoGet (dpy);
+ XftFtFile *file;
+ FT_Face face;
+ XftFtGlyphSet *gs;
+ char *filename;
+ int id;
+ double dsize;
+ FT_F26Dot6 size;
+ int rgba;
+ int spacing;
+ int char_width;
+ Bool antialias;
+ Bool minspace;
+ char *encoding_name;
+ XftFontStruct *font;
+ int j;
+ FT_Encoding encoding;
+ int charmap;
+ FT_Matrix matrix;
+ XftMatrix *font_matrix;
+
+#if 0
+ int extra;
+#endif
+ int height, ascent, descent;
+ XRenderPictFormat pf, *format;
+
+ /*
+ * Open the file
+ */
+ if (XftPatternGetString (pattern, XFT_FILE, 0, &filename) != XftResultMatch)
+ goto bail0;
+
+ if (XftPatternGetInteger (pattern, XFT_INDEX, 0, &id) != XftResultMatch)
+ goto bail0;
+
+ file = _XftFreeTypeOpenFile (filename, id);
+ if (!file)
+ goto bail0;
+
+ face = file->face;
+
+ /*
+ * Extract the glyphset information from the pattern
+ */
+ if (XftPatternGetString (pattern, XFT_ENCODING, 0, &encoding_name) != XftResultMatch)
+ goto bail0;
+
+ if (XftPatternGetDouble (pattern, XFT_PIXEL_SIZE, 0, &dsize) != XftResultMatch)
+ goto bail0;
+
+ switch (XftPatternGetInteger (pattern, XFT_RGBA, 0, &rgba)) {
+ case XftResultNoMatch:
+ rgba = XFT_RGBA_NONE;
+ break;
+ case XftResultMatch:
+ break;
+ default:
+ goto bail0;
+ }
+
+ switch (XftPatternGetBool (pattern, XFT_ANTIALIAS, 0, &antialias)) {
+ case XftResultNoMatch:
+ antialias = True;
+ break;
+ case XftResultMatch:
+ break;
+ default:
+ goto bail0;
+ }
+
+ switch (XftPatternGetBool (pattern, XFT_MINSPACE, 0, &minspace)) {
+ case XftResultNoMatch:
+ minspace = False;
+ break;
+ case XftResultMatch:
+ break;
+ default:
+ goto bail0;
+ }
+
+ switch (XftPatternGetInteger (pattern, XFT_SPACING, 0, &spacing)) {
+ case XftResultNoMatch:
+ spacing = XFT_PROPORTIONAL;
+ break;
+ case XftResultMatch:
+ break;
+ default:
+ goto bail1;
+ }
+
+ if (XftPatternGetInteger (pattern, XFT_CHAR_WIDTH,
+ 0, &char_width) != XftResultMatch)
+ {
+ char_width = 0;
+ }
+ else if (char_width)
+ spacing = XFT_MONO;
+
+ matrix.xx = matrix.yy = 0x10000;
+ matrix.xy = matrix.yx = 0;
+
+ switch (XftPatternGetMatrix (pattern, XFT_MATRIX, 0, &font_matrix)) {
+ case XftResultNoMatch:
+ break;
+ case XftResultMatch:
+ matrix.xx = 0x10000L * font_matrix->xx;
+ matrix.yy = 0x10000L * font_matrix->yy;
+ matrix.xy = 0x10000L * font_matrix->xy;
+ matrix.yx = 0x10000L * font_matrix->yx;
+ break;
+ default:
+ goto bail1;
+ }
+
+
+
+ if (XftPatternGetInteger (pattern, XFT_CHAR_WIDTH,
+ 0, &char_width) != XftResultMatch)
+ {
+ char_width = 0;
+ }
+ else if (char_width)
+ spacing = XFT_MONO;
+
+ encoding = face->charmaps[0]->encoding;
+
+ for (j = 0; j < NUM_FT_ENCODINGS; j++)
+ if (!strcmp (encoding_name, xftFtEncoding[j].name))
+ {
+ encoding = xftFtEncoding[j].encoding;
+ break;
+ }
+
+ size = (FT_F26Dot6) (dsize * 64.0);
+
+ if (encoding == ft_encoding_none)
+ charmap = -1;
+ else
+ {
+ for (charmap = 0; charmap < face->num_charmaps; charmap++)
+ if (face->charmaps[charmap]->encoding == encoding)
+ break;
+
+ if (charmap == face->num_charmaps)
+ goto bail1;
+ }
+
+
+ /*
+ * Match an existing glyphset
+ */
+ for (gs = info->glyphSets; gs; gs = gs->next)
+ {
+ if (gs->file == file &&
+ gs->minspace == minspace &&
+ gs->char_width == char_width &&
+ gs->font.size == size &&
+ gs->font.spacing == spacing &&
+ gs->font.charmap == charmap &&
+ gs->font.rgba == rgba &&
+ gs->font.antialias == antialias &&
+ FT_Matrix_Equal (&gs->font.matrix, &matrix))
+ {
+ ++gs->ref;
+ if (_XftFontDebug () & XFT_DBG_REF)
+ {
+ printf ("Face size %g matches existing (%d)\n",
+ dsize, gs->ref);
+ }
+ return &gs->font;
+ }
+ }
+
+ if (_XftFontDebug () & XFT_DBG_REF)
+ {
+ printf ("Face size %g matches new\n",
+ dsize);
+ }
+ /*
+ * No existing glyphset, create another
+ */
+ gs = malloc (sizeof (XftFtGlyphSet));
+ if (!gs)
+ goto bail1;
+
+ gs->ref = 1;
+
+ gs->file = file;
+ gs->minspace = minspace;
+ gs->char_width = char_width;
+
+ font = &gs->font;
+
+ if (antialias)
+ {
+ switch (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 bail2;
+
+ if (!XftFreeTypeSetFace (face, size, charmap, &matrix))
+ goto bail2;
+
+ descent = -(face->size->metrics.descender >> 6);
+ ascent = face->size->metrics.ascender >> 6;
+ if (minspace)
+ {
+ height = ascent + descent;
+ }
+ else
+ {
+ height = face->size->metrics.height >> 6;
+#if 0
+ extra = (height - (ascent + descent));
+ if (extra > 0)
+ {
+ ascent = ascent + extra / 2;
+ descent = height - ascent;
+ }
+ else if (extra < 0)
+ height = ascent + descent;
+#endif
+ }
+ font->ascent = ascent;
+ font->descent = descent;
+ font->height = height;
+
+ if (char_width)
+ font->max_advance_width = char_width;
+ else
+ font->max_advance_width = face->size->metrics.max_advance >> 6;
+
+ gs->next = info->glyphSets;
+ info->glyphSets = gs;
+
+ font->glyphset = XRenderCreateGlyphSet (dpy, format);
+
+ font->size = size;
+ font->spacing = spacing;
+ font->format = format;
+ font->realized =0;
+ font->nrealized = 0;
+ font->rgba = rgba;
+ font->antialias = antialias;
+ font->charmap = charmap;
+ font->transform = (matrix.xx != 0x10000 || matrix.xy != 0 ||
+ matrix.yx != 0 || matrix.yy != 0x10000);
+ font->matrix = matrix;
+ font->face = face;
+
+ return font;
+
+bail2:
+ free (gs);
+bail1:
+ _XftFreeTypeCloseFile (file);
+bail0:
+ return 0;
+}
+
+void
+XftFreeTypeClose (Display *dpy, XftFontStruct *font)
+{
+ XftFtGlyphSet *gs, **prev;
+ XftDisplayInfo *info = _XftDisplayInfoGet (dpy);
+ int i;
+ XGlyphInfo *gi;
+
+ for (prev = &info->glyphSets; (gs = *prev); prev = &gs->next)
+ {
+ if (&gs->font == font)
+ {
+ if (--gs->ref == 0)
+ {
+ XRenderFreeGlyphSet (dpy, font->glyphset);
+ for (i = 0; i < font->nrealized; i++)
+ {
+ gi = font->realized[i];
+ if (gi && gi != XftUntestedGlyph)
+ free (gi);
+ }
+ if (font->realized)
+ free (font->realized);
+
+ _XftFreeTypeCloseFile (gs->file);
+
+ *prev = gs->next;
+ free (gs);
+ }
+ break;
+ }
+ }
+}
+
+XftFontStruct *
+XftFreeTypeGet (XftFont *font)
+{
+ if (font->core)
+ return 0;
+ return font->u.ft.font;
+}
+
+/* #define XFT_DEBUG_FONTSET */
+
+Bool
+XftInitFtLibrary (void)
+{
+ if (_XftFTlibrary)
+ return True;
+ if (FT_Init_FreeType (&_XftFTlibrary))
+ return False;
+ _XftFontSet = FcConfigGetFonts (0, FcSetSystem);
+ if (!_XftFontSet)
+ return False;
+ return True;
+}
diff --git a/nx-X11/lib/Xft1/xftfs.c b/nx-X11/lib/Xft1/xftfs.c
new file mode 100644
index 000000000..a246b2056
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftfs.c
@@ -0,0 +1,44 @@
+/*
+ * $XFree86$
+ *
+ * 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 <stdlib.h>
+#include "xftint.h"
+
+XftFontSet *
+XftFontSetCreate (void)
+{
+ return FcFontSetCreate ();
+}
+
+void
+XftFontSetDestroy (XftFontSet *s)
+{
+ FcFontSetDestroy (s);
+}
+
+Bool
+XftFontSetAdd (XftFontSet *s, XftPattern *font)
+{
+ return FcFontSetAdd (s, font);
+}
diff --git a/nx-X11/lib/Xft1/xftglyphs.c b/nx-X11/lib/Xft1/xftglyphs.c
new file mode 100644
index 000000000..1e23d0a0b
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftglyphs.c
@@ -0,0 +1,491 @@
+/*
+ * $XFree86: xc/lib/Xft1/xftglyphs.c,v 1.3 2003/05/27 22:26:41 tsi 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "xftint.h"
+#include <ft2build.h>
+#include FT_OUTLINE_H
+
+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 },
+};
+
+void
+XftGlyphLoad (Display *dpy,
+ XftFontStruct *font,
+ XftChar32 *glyphs,
+ int nglyph)
+{
+ FT_Error error;
+ FT_ULong charcode;
+ FT_UInt glyphindex;
+ FT_GlyphSlot glyph;
+ XGlyphInfo *gi;
+ Glyph g;
+ 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;
+
+ if (!XftFreeTypeSetFace (font->face, font->size, font->charmap, &font->matrix))
+ return ;
+
+ matrix.xx = matrix.yy = 0x10000L;
+ matrix.xy = matrix.yx = 0;
+
+ if (font->antialias)
+ {
+ switch (font->rgba) {
+ case XFT_RGBA_RGB:
+ case XFT_RGBA_BGR:
+ matrix.xx *= 3;
+ subpixel = True;
+ hmul = 3;
+ break;
+ case XFT_RGBA_VRGB:
+ case XFT_RGBA_VBGR:
+ matrix.yy *= 3;
+ vmul = 3;
+ subpixel = True;
+ break;
+ }
+ }
+
+ while (nglyph--)
+ {
+ charcode = (FT_ULong) *glyphs++;
+ gi = font->realized[charcode];
+ if (!gi)
+ continue;
+
+ if (font->charmap != -1)
+ {
+ glyphindex = FT_Get_Char_Index (font->face, charcode);
+#if 0
+ if (!glyphindex)
+ {
+ if (_XftFontDebug() & XFT_DBG_GLYPH)
+ printf ("glyph (%c) %d missing\n",
+ (int) charcode, (int) charcode);
+ continue;
+ }
+#endif
+ }
+ else
+ glyphindex = (FT_UInt) charcode;
+ error = FT_Load_Glyph (font->face, glyphindex, 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)
+
+ glyph = font->face->glyph;
+
+ if(font->transform)
+ {
+ /*
+ * 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 = glyph->metrics.horiBearingX + xc * glyph->metrics.width;
+ vector.y = glyph->metrics.horiBearingY - yc * glyph->metrics.height;
+ FT_Vector_Transform(&vector, &font->matrix);
+ if (_XftFontDebug() & 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( glyph->metrics.horiBearingX );
+ right = CEIL( glyph->metrics.horiBearingX + glyph->metrics.width );
+
+ top = CEIL( glyph->metrics.horiBearingY );
+ bottom = FLOOR( glyph->metrics.horiBearingY - glyph->metrics.height );
+ }
+
+ width = TRUNC(right - left);
+ height = TRUNC( top - bottom );
+
+
+ /*
+ * Try to keep monospace fonts ink-inside
+ * XXX transformed?
+ */
+ if (font->spacing != XFT_PROPORTIONAL && !font->transform)
+ {
+ if (TRUNC(right) > font->max_advance_width)
+ {
+ int adjust;
+
+ adjust = right - (font->max_advance_width << 6);
+ if (adjust > left)
+ adjust = left;
+ left -= adjust;
+ right -= adjust;
+ width = font->max_advance_width;
+ }
+ }
+
+ if ( glyph->format == ft_glyph_format_outline )
+ {
+ if (font->antialias)
+ pitch = (width * hmul + 3) & ~3;
+ else
+ pitch = ((width + 31) & ~31) >> 3;
+
+ size = pitch * height * vmul;
+
+ if (size > bufSize)
+ {
+ if (bufBitmap != bufLocal)
+ free (bufBitmap);
+ bufBitmap = (unsigned char *) malloc (size);
+ if (!bufBitmap)
+ continue;
+ bufSize = size;
+ }
+ memset (bufBitmap, 0, size);
+
+ ftbit.width = width * hmul;
+ ftbit.rows = height * vmul;
+ ftbit.pitch = pitch;
+ if (font->antialias)
+ ftbit.pixel_mode = ft_pixel_mode_grays;
+ else
+ ftbit.pixel_mode = ft_pixel_mode_mono;
+
+ ftbit.buffer = bufBitmap;
+
+ if (subpixel)
+ FT_Outline_Transform (&glyph->outline, &matrix);
+
+ FT_Outline_Translate ( &glyph->outline, -left*hmul, -bottom*vmul );
+
+ FT_Outline_Get_Bitmap( _XftFTlibrary, &glyph->outline, &ftbit );
+
+ /*
+ * swap bit order around
+ */
+ if (!font->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 (_XftFontDebug() & XFT_DBG_GLYPH)
+ {
+ printf ("char 0x%x (%c):\n", (int) charcode, (char) charcode);
+ printf (" xywh (%d %d %d %d), trans (%d %d %d %d) wh (%d %d)\n",
+ (int) glyph->metrics.horiBearingX,
+ (int) glyph->metrics.horiBearingY,
+ (int) glyph->metrics.width,
+ (int) glyph->metrics.height,
+ left, right, top, bottom,
+ width, height);
+ if (_XftFontDebug() & XFT_DBG_GLYPHV)
+ {
+ int x, y;
+ unsigned char *line;
+
+ line = bufBitmap;
+ for (y = 0; y < height * vmul; y++)
+ {
+ if (font->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");
+ }
+ }
+ }
+ else
+ {
+ if (_XftFontDebug() & XFT_DBG_GLYPH)
+ printf ("glyph (%c) %d no outline\n",
+ (int) charcode, (int) charcode);
+ continue;
+ }
+
+ gi->width = width;
+ gi->height = height;
+ gi->x = -TRUNC(left);
+ gi->y = TRUNC(top);
+ if (font->spacing != XFT_PROPORTIONAL)
+ {
+ if (font->transform)
+ {
+ vector.x = font->max_advance_width;
+ vector.y = 0;
+ FT_Vector_Transform (&vector, &font->matrix);
+ gi->xOff = vector.x;
+ gi->yOff = -vector.y;
+ }
+ else
+ {
+ gi->xOff = font->max_advance_width;
+ gi->yOff = 0;
+ }
+ }
+ else
+ {
+ gi->xOff = TRUNC(ROUND(glyph->advance.x));
+ gi->yOff = -TRUNC(ROUND(glyph->advance.y));
+ }
+ g = charcode;
+
+ 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;
+
+ widthrgba = width;
+ pitchrgba = (widthrgba * 4 + 3) & ~3;
+ sizergba = pitchrgba * height;
+
+ os = 1;
+ switch (font->rgba) {
+ case XFT_RGBA_VRGB:
+ os = pitch;
+ case XFT_RGBA_RGB:
+ default:
+ rf = 0;
+ gf = 1;
+ bf = 2;
+ break;
+ case XFT_RGBA_VBGR:
+ os = pitch;
+ case XFT_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;
+ }
+ }
+
+ XRenderAddGlyphs (dpy, font->glyphset, &g, gi, 1,
+ (char *) bufBitmapRgba, sizergba);
+ }
+ else
+ {
+ XRenderAddGlyphs (dpy, font->glyphset, &g, gi, 1,
+ (char *) bufBitmap, size);
+ }
+ }
+ if (bufBitmap != bufLocal)
+ free (bufBitmap);
+ if (bufBitmapRgba != bufLocalRgba)
+ free (bufBitmapRgba);
+}
+
+#define STEP 256
+
+/*
+ * Return whether the given glyph generates any image on the screen,
+ * this means it exists or a default glyph exists
+ */
+static Bool
+XftGlyphDrawable (Display *dpy,
+ XftFontStruct *font,
+ XftChar32 glyph)
+{
+ if (font->charmap != -1)
+ {
+ FT_Set_Charmap (font->face, font->face->charmaps[font->charmap]);
+ glyph = (XftChar32) FT_Get_Char_Index (font->face, (FT_ULong) glyph);
+ }
+ return glyph <= font->face->num_glyphs;
+}
+
+void
+XftGlyphCheck (Display *dpy,
+ XftFontStruct *font,
+ XftChar32 glyph,
+ XftChar32 *missing,
+ int *nmissing)
+{
+ XGlyphInfo **realized;
+ int nrealized;
+ int n;
+
+ if (glyph >= font->nrealized)
+ {
+ nrealized = glyph + STEP;
+
+ if (font->realized)
+ realized = (XGlyphInfo **) realloc ((void *) font->realized,
+ nrealized * sizeof (XGlyphInfo *));
+ else
+ realized = (XGlyphInfo **) malloc (nrealized * sizeof (XGlyphInfo *));
+ if (!realized)
+ return;
+ for (n = font->nrealized; n < nrealized; n++)
+ realized[n] = XftUntestedGlyph;
+
+ font->realized = realized;
+ font->nrealized = nrealized;
+ }
+ if (font->realized[glyph] == XftUntestedGlyph)
+ {
+ if (XftGlyphDrawable (dpy, font, glyph))
+ {
+ font->realized[glyph] = (XGlyphInfo *) malloc (sizeof (XGlyphInfo));
+ n = *nmissing;
+ missing[n++] = glyph;
+ if (n == XFT_NMISSING)
+ {
+ XftGlyphLoad (dpy, font, missing, n);
+ n = 0;
+ }
+ *nmissing = n;
+ }
+ else
+ font->realized[glyph] = 0;
+ }
+}
+
+Bool
+XftFreeTypeGlyphExists (Display *dpy,
+ XftFontStruct *font,
+ XftChar32 glyph)
+{
+ if (font->charmap != -1)
+ {
+ FT_Set_Charmap (font->face, font->face->charmaps[font->charmap]);
+ glyph = (XftChar32) FT_Get_Char_Index (font->face, (FT_ULong) glyph);
+ }
+ return glyph && glyph <= font->face->num_glyphs;
+}
diff --git a/nx-X11/lib/Xft1/xftgram.y b/nx-X11/lib/Xft1/xftgram.y
new file mode 100644
index 000000000..04e231e7c
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftgram.y
@@ -0,0 +1,452 @@
+/*
+ * $XFree86: xc/lib/Xft/xftgram.y,v 1.5 2001/05/16 10:32:54 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 <stdlib.h>
+#include <stdio.h>
+#include "xftint.h"
+
+static XftMatrix matrix;
+
+%}
+
+%union {
+ int ival;
+ double dval;
+ char *sval;
+ XftExpr *eval;
+ XftPattern *pval;
+ XftValue vval;
+ XftEdit *Eval;
+ XftOp oval;
+ XftQual qval;
+ XftTest *tval;
+}
+
+%token <ival> INTEGER
+%token <dval> DOUBLE
+%token <sval> STRING NAME
+%token <ival> ANY ALL
+%token <ival> DIR CACHE INCLUDE INCLUDEIF MATCH EDIT
+%token <ival> TOK_TRUE TOK_FALSE TOK_NIL
+%token <ival> EQUAL SEMI OS CS
+
+%type <eval> expr
+%type <vval> value
+%type <sval> field
+%type <Eval> edit
+%type <Eval> edits
+%type <oval> eqop
+%type <qval> qual
+%type <oval> compare
+%type <tval> tests test
+%type <dval> number
+
+%right <ival> QUEST COLON
+%left <ival> OROR
+%left <ival> ANDAND
+%left <ival> EQEQ NOTEQ
+%left <ival> LESS LESSEQ MORE MOREEQ
+%left <ival> PLUS MINUS
+%left <ival> TIMES DIVIDE
+%right <ival> NOT
+
+%%
+configs : configs config
+ |
+ ;
+config : DIR STRING
+ { XftConfigAddDir ($2); }
+ | CACHE STRING
+ { XftConfigSetCache ($2); }
+ | INCLUDE STRING
+ { XftConfigPushInput ($2, True); }
+ | INCLUDEIF STRING
+ { XftConfigPushInput ($2, False); }
+ | MATCH tests EDIT edits
+ { XftConfigAddEdit ($2, $4); }
+ ;
+tests : test tests
+ { $1->next = $2; $$ = $1; }
+ |
+ { $$ = 0; }
+ ;
+test : qual field compare value
+ { $$ = XftTestCreate ($1, $2, $3, $4); }
+ ;
+qual : ANY
+ { $$ = XftQualAny; }
+ | ALL
+ { $$ = XftQualAll; }
+ |
+ { $$ = XftQualAny; }
+ ;
+field : NAME
+ {
+ $$ = XftConfigSaveField ($1);
+ }
+ ;
+compare : EQUAL
+ { $$ = XftOpEqual; }
+ | EQEQ
+ { $$ = XftOpEqual; }
+ | NOTEQ
+ { $$ = XftOpNotEqual; }
+ | LESS
+ { $$ = XftOpLess; }
+ | LESSEQ
+ { $$ = XftOpLessEqual; }
+ | MORE
+ { $$ = XftOpMore; }
+ | MOREEQ
+ { $$ = XftOpMoreEqual; }
+ ;
+value : INTEGER
+ {
+ $$.type = XftTypeInteger;
+ $$.u.i = $1;
+ }
+ | DOUBLE
+ {
+ $$.type = XftTypeDouble;
+ $$.u.d = $1;
+ }
+ | STRING
+ {
+ $$.type = XftTypeString;
+ $$.u.s = $1;
+ }
+ | TOK_TRUE
+ {
+ $$.type = XftTypeBool;
+ $$.u.b = True;
+ }
+ | TOK_FALSE
+ {
+ $$.type = XftTypeBool;
+ $$.u.b = False;
+ }
+ | TOK_NIL
+ {
+ $$.type = XftTypeVoid;
+ }
+ | matrix
+ {
+ $$.type = XftTypeMatrix;
+ $$.u.m = &matrix;
+ }
+ ;
+matrix : OS number number number number CS
+ {
+ matrix.xx = $2;
+ matrix.xy = $3;
+ matrix.yx = $4;
+ matrix.__REALLY_YY__ = $5;
+ }
+number : INTEGER
+ { $$ = (double) $1; }
+ | DOUBLE
+ ;
+edits : edit edits
+ { $1->next = $2; $$ = $1; }
+ |
+ { $$ = 0; }
+ ;
+edit : field eqop expr SEMI
+ { $$ = XftEditCreate ($1, $2, $3); }
+ ;
+eqop : EQUAL
+ { $$ = XftOpAssign; }
+ | PLUS EQUAL
+ { $$ = XftOpPrepend; }
+ | EQUAL PLUS
+ { $$ = XftOpAppend; }
+ ;
+expr : INTEGER
+ { $$ = XftExprCreateInteger ($1); }
+ | DOUBLE
+ { $$ = XftExprCreateDouble ($1); }
+ | STRING
+ { $$ = XftExprCreateString ($1); }
+ | TOK_TRUE
+ { $$ = XftExprCreateBool (True); }
+ | TOK_FALSE
+ { $$ = XftExprCreateBool (False); }
+ | TOK_NIL
+ { $$ = XftExprCreateNil (); }
+ | matrix
+ { $$ = XftExprCreateMatrix (&matrix); }
+ | NAME
+ { $$ = XftExprCreateField ($1); }
+ | expr OROR expr
+ { $$ = XftExprCreateOp ($1, XftOpOr, $3); }
+ | expr ANDAND expr
+ { $$ = XftExprCreateOp ($1, XftOpAnd, $3); }
+ | expr EQEQ expr
+ { $$ = XftExprCreateOp ($1, XftOpEqual, $3); }
+ | expr NOTEQ expr
+ { $$ = XftExprCreateOp ($1, XftOpNotEqual, $3); }
+ | expr LESS expr
+ { $$ = XftExprCreateOp ($1, XftOpLess, $3); }
+ | expr LESSEQ expr
+ { $$ = XftExprCreateOp ($1, XftOpLessEqual, $3); }
+ | expr MORE expr
+ { $$ = XftExprCreateOp ($1, XftOpMore, $3); }
+ | expr MOREEQ expr
+ { $$ = XftExprCreateOp ($1, XftOpMoreEqual, $3); }
+ | expr PLUS expr
+ { $$ = XftExprCreateOp ($1, XftOpPlus, $3); }
+ | expr MINUS expr
+ { $$ = XftExprCreateOp ($1, XftOpMinus, $3); }
+ | expr TIMES expr
+ { $$ = XftExprCreateOp ($1, XftOpTimes, $3); }
+ | expr DIVIDE expr
+ { $$ = XftExprCreateOp ($1, XftOpDivide, $3); }
+ | NOT expr
+ { $$ = XftExprCreateOp ($2, XftOpNot, (XftExpr *) 0); }
+ | expr QUEST expr COLON expr
+ { $$ = XftExprCreateOp ($1, XftOpQuest, XftExprCreateOp ($3, XftOpQuest, $5)); }
+ ;
+%%
+
+int
+XftConfigwrap (void)
+{
+ return 1;
+}
+
+void
+XftConfigerror (char *fmt, ...)
+{
+ va_list args;
+
+ fprintf (stderr, "\"%s\": line %d, ", XftConfigFile, XftConfigLineno);
+ va_start (args, fmt);
+ vfprintf (stderr, fmt, args);
+ va_end (args);
+ fprintf (stderr, "\n");
+}
+
+XftTest *
+XftTestCreate (XftQual qual, const char *field, XftOp compare, XftValue value)
+{
+ XftTest *test = (XftTest *) malloc (sizeof (XftTest));;
+
+ if (test)
+ {
+ test->next = 0;
+ test->qual = qual;
+ test->field = field; /* already saved in grammar */
+ test->op = compare;
+ if (value.type == XftTypeString)
+ value.u.s = _XftSaveString (value.u.s);
+ else if (value.type == XftTypeMatrix)
+ value.u.m = _XftSaveMatrix (value.u.m);
+ test->value = value;
+ }
+ return test;
+}
+
+XftExpr *
+XftExprCreateInteger (int i)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = XftOpInteger;
+ e->u.ival = i;
+ }
+ return e;
+}
+
+XftExpr *
+XftExprCreateDouble (double d)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = XftOpDouble;
+ e->u.dval = d;
+ }
+ return e;
+}
+
+XftExpr *
+XftExprCreateString (const char *s)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = XftOpString;
+ e->u.sval = _XftSaveString (s);
+ }
+ return e;
+}
+
+XftExpr *
+XftExprCreateMatrix (const XftMatrix *m)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = XftOpMatrix;
+ e->u.mval = _XftSaveMatrix (m);
+ }
+ return e;
+}
+
+XftExpr *
+XftExprCreateBool (Bool b)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = XftOpBool;
+ e->u.bval = b;
+ }
+ return e;
+}
+
+XftExpr *
+XftExprCreateNil (void)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = XftOpNil;
+ }
+ return e;
+}
+
+XftExpr *
+XftExprCreateField (const char *field)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = XftOpField;
+ e->u.field = _XftSaveString (field);
+ }
+ return e;
+}
+
+XftExpr *
+XftExprCreateOp (XftExpr *left, XftOp op, XftExpr *right)
+{
+ XftExpr *e = (XftExpr *) malloc (sizeof (XftExpr));
+
+ if (e)
+ {
+ e->op = op;
+ e->u.tree.left = left;
+ e->u.tree.right = right;
+ }
+ return e;
+}
+
+void
+XftExprDestroy (XftExpr *e)
+{
+ switch (e->op) {
+ case XftOpInteger:
+ break;
+ case XftOpDouble:
+ break;
+ case XftOpString:
+ free (e->u.sval);
+ break;
+ case XftOpMatrix:
+ free (e->u.mval);
+ break;
+ case XftOpBool:
+ break;
+ case XftOpField:
+ free (e->u.field);
+ break;
+ case XftOpAssign:
+ case XftOpPrepend:
+ case XftOpAppend:
+ break;
+ case XftOpOr:
+ case XftOpAnd:
+ case XftOpEqual:
+ case XftOpNotEqual:
+ case XftOpLess:
+ case XftOpLessEqual:
+ case XftOpMore:
+ case XftOpMoreEqual:
+ case XftOpPlus:
+ case XftOpMinus:
+ case XftOpTimes:
+ case XftOpDivide:
+ case XftOpQuest:
+ XftExprDestroy (e->u.tree.right);
+ /* fall through */
+ case XftOpNot:
+ XftExprDestroy (e->u.tree.left);
+ break;
+ case XftOpNil:
+ break;
+ }
+ free (e);
+}
+
+XftEdit *
+XftEditCreate (const char *field, XftOp op, XftExpr *expr)
+{
+ XftEdit *e = (XftEdit *) malloc (sizeof (XftEdit));
+
+ if (e)
+ {
+ e->next = 0;
+ e->field = field; /* already saved in grammar */
+ e->op = op;
+ e->expr = expr;
+ }
+ return e;
+}
+
+void
+XftEditDestroy (XftEdit *e)
+{
+ if (e->next)
+ XftEditDestroy (e->next);
+ free ((void *) e->field);
+ if (e->expr)
+ XftExprDestroy (e->expr);
+}
+
+char *
+XftConfigSaveField (const char *field)
+{
+ return _XftSaveString (field);
+}
diff --git a/nx-X11/lib/Xft1/xftinit.c b/nx-X11/lib/Xft1/xftinit.c
new file mode 100644
index 000000000..79e589160
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftinit.c
@@ -0,0 +1,42 @@
+/*
+ * $XFree86: xc/lib/Xft1/xftinit.c,v 1.3 2002/03/01 20:33:33 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 <stdlib.h>
+#include "xftint.h"
+
+XftFontSet *_XftFontSet;
+Bool _XftConfigInitialized;
+static char *nodirs[] = { 0 };
+char **XftConfigDirs = nodirs;
+
+Bool
+XftInit (char *config)
+{
+ if (_XftConfigInitialized)
+ return True;
+ if (!FcInit ())
+ return False;
+ _XftConfigInitialized = True;
+ return True;
+}
diff --git a/nx-X11/lib/Xft1/xftint.h b/nx-X11/lib/Xft1/xftint.h
new file mode 100644
index 000000000..c73fb1723
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftint.h
@@ -0,0 +1,508 @@
+/*
+ * $XFree86: xc/lib/Xft1/xftint.h,v 1.2 2002/03/01 01:00:53 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.
+ */
+
+#ifndef _XFTINT_H_
+#define _XFTINT_H_
+
+#include <X11/Xlib.h>
+#include <fontconfig/fontconfig.h>
+#ifdef FREETYPE2
+#include "XftFreetype.h"
+#else
+#include "Xft.h"
+#endif
+
+typedef struct _XftMatcher {
+ char *object;
+ double (*compare) (char *object, XftValue value1, XftValue value2);
+} XftMatcher;
+
+typedef struct _XftSymbolic {
+ const char *name;
+ int value;
+} XftSymbolic;
+
+#define XFT_DRAW_N_SRC 2
+
+#define XFT_DRAW_SRC_TEXT 0
+#define XFT_DRAW_SRC_RECT 1
+
+struct _XftDraw {
+ Display *dpy;
+ Drawable drawable;
+ Visual *visual; /* NULL for bitmaps */
+ Colormap colormap;
+ Region clip;
+ Bool core_set;
+ Bool render_set;
+ Bool render_able;
+ struct {
+ Picture pict;
+ struct {
+ Picture pict;
+ XRenderColor color;
+ } src[XFT_DRAW_N_SRC];
+ } render;
+ struct {
+ GC draw_gc;
+ unsigned long fg;
+ Font font;
+ } core;
+};
+
+typedef struct _XftDisplayInfo {
+ struct _XftDisplayInfo *next;
+ Display *display;
+ XExtCodes *codes;
+ XftPattern *defaults;
+ XftFontSet *coreFonts;
+ Bool hasRender;
+ struct _XftFtGlyphSet *glyphSets;
+} XftDisplayInfo;
+
+extern XftFontSet *_XftGlobalFontSet;
+extern XftDisplayInfo *_XftDisplayInfo;
+extern char **XftConfigDirs;
+extern XftFontSet *_XftFontSet;
+
+typedef struct _FcPatternElt FcPatternElt;
+
+/*
+ * Yes, these are stolen from fcint.h
+ */
+FcPatternElt *
+FcPatternFindElt (const FcPattern *p, const char *object);
+
+FcPatternElt *
+FcPatternInsertElt (FcPattern *p, const char *object);
+
+typedef FcPatternElt XftPatternElt;
+
+#define XFT_NMISSING 256
+
+#ifndef XFT_DEFAULT_PATH
+#define XFT_DEFAULT_PATH "/usr/X11R6/lib/X11/XftConfig"
+#endif
+
+#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_MATCH 512
+#define XFT_DBG_MATCHV 1024
+#define XFT_DBG_EDIT 2048
+
+typedef enum _XftOp {
+ XftOpInteger, XftOpDouble, XftOpString, XftOpMatrix, XftOpBool, XftOpNil,
+ XftOpField,
+ XftOpAssign, XftOpPrepend, XftOpAppend,
+ XftOpQuest,
+ XftOpOr, XftOpAnd, XftOpEqual, XftOpNotEqual,
+ XftOpLess, XftOpLessEqual, XftOpMore, XftOpMoreEqual,
+ XftOpPlus, XftOpMinus, XftOpTimes, XftOpDivide,
+ XftOpNot
+} XftOp;
+
+typedef struct _XftExpr {
+ XftOp op;
+ union {
+ int ival;
+ double dval;
+ char *sval;
+ XftMatrix *mval;
+ Bool bval;
+ char *field;
+ struct {
+ struct _XftExpr *left, *right;
+ } tree;
+ } u;
+} XftExpr;
+
+typedef enum _XftQual {
+ XftQualAny, XftQualAll
+} XftQual;
+
+typedef struct _XftTest {
+ struct _XftTest *next;
+ XftQual qual;
+ const char *field;
+ XftOp op;
+ XftValue value;
+} XftTest;
+
+typedef struct _XftEdit {
+ struct _XftEdit *next;
+ const char *field;
+ XftOp op;
+ XftExpr *expr;
+} XftEdit;
+
+typedef struct _XftSubst {
+ struct _XftSubst *next;
+ XftTest *test;
+ XftEdit *edit;
+} XftSubst;
+
+/*
+ * I tried this with functions that took va_list* arguments
+ * but portability concerns made me change these functions
+ * into macros (sigh).
+ */
+
+#define _XftPatternVapBuild(result, orig, va) \
+{ \
+ XftPattern *__p__ = (orig); \
+ const char *__o__; \
+ XftValue __v__; \
+ \
+ if (!__p__) \
+ { \
+ __p__ = XftPatternCreate (); \
+ if (!__p__) \
+ goto _XftPatternVapBuild_bail0; \
+ } \
+ for (;;) \
+ { \
+ __o__ = va_arg (va, const char *); \
+ if (!__o__) \
+ break; \
+ __v__.type = va_arg (va, XftType); \
+ switch (__v__.type) { \
+ case XftTypeVoid: \
+ goto _XftPatternVapBuild_bail1; \
+ case XftTypeInteger: \
+ __v__.u.i = va_arg (va, int); \
+ break; \
+ case XftTypeDouble: \
+ __v__.u.d = va_arg (va, double); \
+ break; \
+ case XftTypeString: \
+ __v__.u.s = va_arg (va, char *); \
+ break; \
+ case XftTypeBool: \
+ __v__.u.b = va_arg (va, Bool); \
+ break; \
+ case XftTypeMatrix: \
+ __v__.u.m = va_arg (va, XftMatrix *); \
+ break; \
+ } \
+ if (!XftPatternAdd (__p__, __o__, __v__, True)) \
+ goto _XftPatternVapBuild_bail1; \
+ } \
+ result = __p__; \
+ goto _XftPatternVapBuild_return; \
+ \
+_XftPatternVapBuild_bail1: \
+ if (!orig) \
+ XftPatternDestroy (__p__); \
+_XftPatternVapBuild_bail0: \
+ result = 0; \
+ \
+_XftPatternVapBuild_return: \
+ ; \
+}
+
+
+/* xftcache.c */
+
+char *
+XftFileCacheFind (char *file, int id, int *count);
+
+void
+XftFileCacheDispose (void);
+
+void
+XftFileCacheLoad (char *cache);
+
+Bool
+XftFileCacheUpdate (char *file, int id, char *name);
+
+Bool
+XftFileCacheSave (char *cache);
+
+Bool
+XftFileCacheReadDir (XftFontSet *set, const char *cache_file);
+
+Bool
+XftFileCacheWriteDir (XftFontSet *set, const char *cache_file);
+
+/* xftcfg.c */
+Bool
+XftConfigAddDir (char *d);
+
+Bool
+XftConfigSetCache (char *c);
+
+char *
+XftConfigGetCache (void);
+
+Bool
+XftConfigAddEdit (XftTest *test, XftEdit *edit);
+
+Bool
+_XftConfigCompareValue (XftValue m,
+ XftOp op,
+ XftValue v);
+
+/* xftcore.c */
+
+#define XFT_CORE_N16LOCAL 256
+
+XChar2b *
+XftCoreConvert16 (XftChar16 *string,
+ int len,
+ XChar2b xcloc[XFT_CORE_N16LOCAL]);
+
+XChar2b *
+XftCoreConvert32 (XftChar32 *string,
+ int len,
+ XChar2b xcloc[XFT_CORE_N16LOCAL]);
+
+XChar2b *
+XftCoreConvertUtf8 (XftChar8 *string,
+ int len,
+ XChar2b xcloc[XFT_CORE_N16LOCAL],
+ int *nchar);
+
+void
+XftCoreExtents8 (Display *dpy,
+ XFontStruct *fs,
+ XftChar8 *string,
+ int len,
+ XGlyphInfo *extents);
+
+void
+XftCoreExtents16 (Display *dpy,
+ XFontStruct *fs,
+ XftChar16 *string,
+ int len,
+ XGlyphInfo *extents);
+
+void
+XftCoreExtents32 (Display *dpy,
+ XFontStruct *fs,
+ XftChar32 *string,
+ int len,
+ XGlyphInfo *extents);
+
+void
+XftCoreExtentsUtf8 (Display *dpy,
+ XFontStruct *fs,
+ XftChar8 *string,
+ int len,
+ XGlyphInfo *extents);
+
+Bool
+XftCoreGlyphExists (Display *dpy,
+ XFontStruct *fs,
+ XftChar32 glyph);
+
+/* xftdbg.c */
+void
+XftOpPrint (XftOp op);
+
+void
+XftTestPrint (XftTest *test);
+
+void
+XftExprPrint (XftExpr *expr);
+
+void
+XftEditPrint (XftEdit *edit);
+
+void
+XftSubstPrint (XftSubst *subst);
+
+/* xftdpy.c */
+XftDisplayInfo *
+_XftDisplayInfoGet (Display *dpy);
+
+int
+XftDefaultParseBool (char *v);
+
+Bool
+XftDefaultGetBool (Display *dpy, const char *object, int screen, Bool def);
+
+int
+XftDefaultGetInteger (Display *dpy, const char *object, int screen, int def);
+
+double
+XftDefaultGetDouble (Display *dpy, const char *object, int screen, double def);
+
+XftFontSet *
+XftDisplayGetFontSet (Display *dpy);
+
+/* xftdraw.c */
+Bool
+XftDrawRenderPrepare (XftDraw *draw,
+ XftColor *color,
+ XftFont *font,
+ int src);
+
+Bool
+XftDrawCorePrepare (XftDraw *draw,
+ XftColor *color,
+ XftFont *font);
+
+/* xftextent.c */
+/* xftfont.c */
+int
+_XftFontDebug (void);
+
+/* xftfs.c */
+/* xftgram.y */
+int
+XftConfigparse (void);
+
+int
+XftConfigwrap (void);
+
+void
+XftConfigerror (char *fmt, ...);
+
+char *
+XftConfigSaveField (const char *field);
+
+XftTest *
+XftTestCreate (XftQual qual, const char *field, XftOp compare, XftValue value);
+
+XftExpr *
+XftExprCreateInteger (int i);
+
+XftExpr *
+XftExprCreateDouble (double d);
+
+XftExpr *
+XftExprCreateString (const char *s);
+
+XftExpr *
+XftExprCreateMatrix (const XftMatrix *m);
+
+XftExpr *
+XftExprCreateBool (Bool b);
+
+XftExpr *
+XftExprCreateNil (void);
+
+XftExpr *
+XftExprCreateField (const char *field);
+
+XftExpr *
+XftExprCreateOp (XftExpr *left, XftOp op, XftExpr *right);
+
+void
+XftExprDestroy (XftExpr *e);
+
+XftEdit *
+XftEditCreate (const char *field, XftOp op, XftExpr *expr);
+
+void
+XftEditDestroy (XftEdit *e);
+
+/* xftinit.c */
+
+/* xftlex.l */
+extern int XftConfigLineno;
+extern char *XftConfigFile;
+
+int
+XftConfiglex (void);
+
+Bool
+XftConfigLexFile(char *s);
+
+Bool
+XftConfigPushInput (char *s, Bool complain);
+
+/* xftlist.c */
+Bool
+XftListValueCompare (XftValue v1,
+ XftValue v2);
+
+Bool
+XftListMatch (XftPattern *p,
+ XftPattern *font,
+ XftQual qual);
+
+Bool
+XftListAppend (XftFontSet *s,
+ XftPattern *font,
+ XftObjectSet *os);
+
+
+/* xftmatch.c */
+
+/* xftname.c */
+Bool
+XftNameConstant (char *string, int *result);
+
+/* xftpat.c */
+
+extern FcPatternElt *
+FcPatternFind (FcPattern *p, const char *object, FcBool insert);
+
+XftPatternElt *
+XftPatternFind (XftPattern *p, const char *object, FcBool insert);
+
+/* xftrender.c */
+
+/* xftmatrix.c */
+XftMatrix *
+_XftSaveMatrix (const XftMatrix *mat);
+
+/* xftstr.c */
+char *
+_XftSaveString (const char *s);
+
+const char *
+_XftGetInt(const char *ptr, int *val);
+
+char *
+_XftSplitStr (const char *field, char *save);
+
+char *
+_XftDownStr (const char *field, char *save);
+
+const char *
+_XftSplitField (const char *field, char *save);
+
+const char *
+_XftSplitValue (const char *field, char *save);
+
+int
+_XftMatchSymbolic (XftSymbolic *s, int n, const char *name, int def);
+
+int
+_XftStrCmpIgnoreCase (const char *s1, const char *s2);
+
+/* xftxlfd.c */
+Bool
+XftCoreAddFonts (XftFontSet *set, Display *dpy, Bool ignore_scalable);
+
+#endif /* _XFT_INT_H_ */
diff --git a/nx-X11/lib/Xft1/xftlex.l b/nx-X11/lib/Xft1/xftlex.l
new file mode 100644
index 000000000..3eff3f429
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftlex.l
@@ -0,0 +1,275 @@
+%{
+/*
+ * $XFree86: xc/lib/Xft/xftlex.l,v 1.7 2001/05/18 16:03:06 tsi Exp $
+ *
+ * Copyright (c) 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 <string.h>
+#include "xftint.h"
+
+#include "xftgram.h"
+
+int XftConfigLineno;
+
+static void _XftConfigSkipComment (void);
+
+static void _XftConfigSkipLine (void);
+
+static int _XftConfigPopInput (void);
+
+
+#define XFT_CONFIG_IN_DEEP 20
+FILE *XftConfigInStack[XFT_CONFIG_IN_DEEP];
+FILE **XftConfigInpt = XftConfigInStack + XFT_CONFIG_IN_DEEP;
+FILE *XftConfigInput;
+int XftConfigLinenos[XFT_CONFIG_IN_DEEP];
+int *XftConfigLinenopt = XftConfigLinenos + XFT_CONFIG_IN_DEEP;
+char *XftConfigFile = "";
+char *XftConfigFileNames[XFT_CONFIG_IN_DEEP];
+char **XftConfigFileNamePt = XftConfigFileNames + XFT_CONFIG_IN_DEEP;
+int XftConfigFiledeep = 0;
+
+#undef YY_INPUT
+
+#define YY_INPUT(buf,result,max_size) \
+{ \
+ int c; \
+ result = 0; \
+ while (result < max_size) { \
+ c = getc (XftConfigInput); \
+ if (c < 0) { \
+ c = _XftConfigPopInput (); \
+ if (c < 0) \
+ break; \
+ } \
+ buf[result++] = c; \
+ if (c == '\n') \
+ { \
+ XftConfigLineno++; \
+ break; \
+ } \
+ } \
+}
+
+#ifndef FLEX_SCANNER
+#undef input
+#undef unput
+static int input (void)
+{
+ char buf[1];
+ static int r = EOF;
+
+ if (r == 0)
+ return 0;
+ YY_INPUT(buf, r, 1);
+ if (r == 0)
+ return EOF;
+ return buf[0];
+}
+
+static void unput (char c)
+{
+ if (!c || c == EOF)
+ return;
+ if (c == '\n')
+ XftConfigLineno--;
+ ungetc (c, XftConfigInput);
+}
+#endif
+
+%}
+%%
+"/\052" _XftConfigSkipComment();
+^# _XftConfigSkipLine();
+dir return DIR;
+cache return CACHE;
+include return INCLUDE;
+includeif return INCLUDEIF;
+match return MATCH;
+edit return EDIT;
+true return TOK_TRUE;
+false return TOK_FALSE;
+nil return TOK_NIL;
+any return ANY;
+all return ALL;
+"=" return EQUAL;
+":" return COLON;
+";" return SEMI;
+"+" return PLUS;
+"-" return MINUS;
+"*" return TIMES;
+"/" return DIVIDE;
+"!" return NOT;
+"&&" return ANDAND;
+"||" return OROR;
+"<" return LESS;
+"<=" return LESSEQ;
+"==" return EQEQ;
+">=" return MOREEQ;
+">" return MORE;
+"!=" return NOTEQ;
+"?" return QUEST;
+"[" return OS;
+"]" return CS;
+\"([^\n\"]|\\\")*\" {
+ yytext[yyleng - 1] = '\0';
+ yylval.sval = yytext+1;
+ return STRING;
+ }
+[0-9]+ {
+ yylval.ival = strtol (yytext, 0, 10);
+ return INTEGER;
+ }
+(([0-9]+((\.[0-9]*(\{[0-9]+\})?)?))|(\.[0-9]+)|(\.[0-9]*\{[0-9]+\}))(([Ee][-+]?[0-9]+)?) {
+ yylval.dval = strtod (yytext, 0);
+ return DOUBLE;
+ }
+[a-zA-Z][0-9a-zA-Z_]* {
+ if (XftNameConstant (yytext, &yylval.ival))
+ return INTEGER;
+ yylval.sval = yytext;
+ return NAME;
+ }
+. ;
+"\n" ;
+%%
+static void
+_XftConfigSkipComment (void)
+{
+ int c;
+
+ c = input();
+ for (;;) {
+ while (c != EOF && c != '*')
+ c = input();
+ if (c == EOF)
+ return;
+ c = input();
+ if (c == EOF || c == '/')
+ return;
+ }
+}
+
+static void
+_XftConfigSkipLine (void)
+{
+ int c;
+
+ do {
+ c = input();
+ } while (c != EOF && c != '\n');
+ if (c == '\n') unput('\n');
+}
+
+Bool
+XftConfigLexFile(char *s)
+{
+ FILE *f;
+
+ f = fopen (s, "r");
+ if (f == 0)
+ {
+ fprintf (stderr, "cannot open file \"%s\"\n", s);
+ return False;
+ }
+ ++XftConfigFiledeep;
+ XftConfigInput = f;
+ XftConfigFile = s;
+ return True;
+}
+
+Bool
+XftConfigPushInput (char *s, Bool complain)
+{
+ FILE *f;
+ char *t;
+ char *h;
+
+ if (XftConfigInpt == XftConfigInStack)
+ {
+ (void) fprintf (stderr, "files nested too deeply\n");
+ return False;
+ }
+ t = s;
+ if (*s == '~')
+ {
+ h = getenv ("HOME");
+ if (h)
+ {
+ t = (char *) malloc (strlen (h) + strlen (s));
+ if (t)
+ {
+ strcpy (t, h);
+ strcat (t, s+1);
+ }
+ else
+ t = s;
+ }
+ }
+ f = fopen (t, "r");
+ if (t != s)
+ free (t);
+ if (f == 0)
+ {
+ if (complain)
+ (void) fprintf (stderr, "cannot open file %s\n", s);
+ return False;
+ }
+ ++XftConfigFiledeep;
+ *--XftConfigInpt = XftConfigInput;
+ *--XftConfigLinenopt = XftConfigLineno;
+ *--XftConfigFileNamePt = XftConfigFile;
+ XftConfigInput = f;
+ XftConfigLineno = 1;
+ XftConfigFile = _XftSaveString (s);
+ return True;
+}
+
+static int
+_XftConfigPopInput (void)
+{
+ int c;
+
+ for (;;)
+ {
+ c = getc (XftConfigInput);
+ if (c >= 0)
+ return c;
+ fclose (XftConfigInput);
+ XftConfigInput = 0;
+ if (XftConfigInpt == XftConfigInStack + XFT_CONFIG_IN_DEEP)
+ return EOF;
+ XftConfigInput = *XftConfigInpt++;
+ XftConfigLineno = *XftConfigLinenopt++;
+ free (XftConfigFile);
+ XftConfigFile = *XftConfigFileNamePt++;
+ --XftConfigFiledeep;
+ }
+}
+
+void
+XftConfigLexDone (void)
+{
+#ifdef FLEX_SCANNER
+ XftConfig_delete_buffer (XftConfig_current_buffer);
+#endif
+}
diff --git a/nx-X11/lib/Xft1/xftlist.c b/nx-X11/lib/Xft1/xftlist.c
new file mode 100644
index 000000000..dca5c42d1
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftlist.c
@@ -0,0 +1,166 @@
+/*
+ * $XFree86: xc/lib/Xft1/xftlist.c,v 1.3 2002/06/21 06:15:14 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 <stdlib.h>
+#include "xftint.h"
+#include <fontconfig/fcprivate.h>
+
+XftObjectSet *
+XftObjectSetCreate (void)
+{
+ return FcObjectSetCreate ();
+}
+
+Bool
+XftObjectSetAdd (XftObjectSet *os, const char *object)
+{
+ return FcObjectSetAdd (os, object);
+}
+
+void
+XftObjectSetDestroy (XftObjectSet *os)
+{
+ FcObjectSetDestroy (os);
+}
+
+
+XftObjectSet *
+XftObjectSetVaBuild (const char *first, va_list va)
+{
+ XftObjectSet *ret;
+
+ FcObjectSetVapBuild (ret, first, va);
+ return ret;
+}
+
+XftObjectSet *
+XftObjectSetBuild (const char *first, ...)
+{
+ va_list va;
+ XftObjectSet *os;
+
+ va_start (va, first);
+ FcObjectSetVapBuild (os, first, va);
+ va_end (va);
+ return os;
+}
+
+XftFontSet *
+XftListFontSets (XftFontSet **sets,
+ int nsets,
+ XftPattern *p,
+ XftObjectSet *os)
+{
+ return FcFontSetList (0, sets, nsets, p, os);
+}
+
+XftFontSet *
+XftListFontsPatternObjects (Display *dpy,
+ int screen,
+ XftPattern *pattern,
+ XftObjectSet *os)
+{
+ XftFontSet *sets[2];
+ int nsets = 0;
+#ifdef FREETYPE2
+ Bool core, render;
+ XftResult result;
+#endif
+ XftPattern *pattern_trim;
+ XftFontSet *ret;
+
+ if (!XftInit (0))
+ return 0;
+
+ pattern_trim = XftPatternDuplicate (pattern);
+ if (!pattern_trim)
+ return 0;
+
+ XftPatternDel (pattern_trim, XFT_CORE);
+ XftPatternDel (pattern_trim, XFT_RENDER);
+#ifdef FREETYPE2
+ render = core = False;
+ result = XftPatternGetBool (pattern, XFT_CORE, 0, &core);
+ if (result != XftResultMatch)
+ core = XftDefaultGetBool (dpy, XFT_CORE, screen,
+ !XftDefaultHasRender (dpy));
+
+ result = XftPatternGetBool (pattern, XFT_RENDER, 0, &render);
+ if (result != XftResultMatch)
+ render = XftDefaultGetBool (dpy, XFT_RENDER, screen,
+ XftDefaultHasRender (dpy));
+ if (render)
+ {
+ /*
+ * fontconfig fonts never include encoding values.
+ * deleting it is something of a kludge as it eliminates the
+ * ability to list core fonts and render fonts of a specific
+ * encoding. Fortunately, Xft1 apps generally don't want core
+ * fonts in any case.
+ */
+ XftPatternDel (pattern_trim, XFT_ENCODING);
+ if (XftInitFtLibrary())
+ {
+ sets[nsets] = _XftFontSet;
+ if (sets[nsets])
+ nsets++;
+ }
+ }
+ if (core)
+#endif
+ {
+ sets[nsets] = XftDisplayGetFontSet (dpy);
+ if (sets[nsets])
+ nsets++;
+ }
+ ret = XftListFontSets (sets, nsets, pattern_trim, os);
+ XftPatternDestroy (pattern_trim);
+ return ret;
+}
+
+XftFontSet *
+XftListFonts (Display *dpy,
+ int screen,
+ ...)
+{
+ va_list va;
+ XftFontSet *fs;
+ XftObjectSet *os;
+ XftPattern *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);
+ XftPatternDestroy (pattern);
+ XftObjectSetDestroy (os);
+ return fs;
+}
diff --git a/nx-X11/lib/Xft1/xftmatch.c b/nx-X11/lib/Xft1/xftmatch.c
new file mode 100644
index 000000000..f764abb9a
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftmatch.c
@@ -0,0 +1,37 @@
+/*
+ * $XFree86: xc/lib/Xft/xftmatch.c,v 1.6 2001/09/21 19:54:53 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 <string.h>
+#include <ctype.h>
+#include "xftint.h"
+#include <stdio.h>
+
+XftPattern *
+XftFontSetMatch (XftFontSet **sets,
+ int nsets,
+ XftPattern *p,
+ XftResult *result)
+{
+ return FcFontSetMatch (0, sets, nsets, p, result);
+}
diff --git a/nx-X11/lib/Xft1/xftmatrix.c b/nx-X11/lib/Xft1/xftmatrix.c
new file mode 100644
index 000000000..7feeccc94
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftmatrix.c
@@ -0,0 +1,104 @@
+/*
+ * $XFree86: xc/lib/Xft/xftmatrix.c,v 1.1 2001/03/30 18:50:18 keithp Exp $
+ *
+ * Copyright © 2000 Tuomas J. Lukka
+ *
+ * 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 Tuomas Lukka not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Tuomas Lukka makes no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * TUOMAS LUKKA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL TUOMAS LUKKA 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 <math.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include "xftint.h"
+
+XftMatrix *
+_XftSaveMatrix (const XftMatrix *mat)
+{
+ XftMatrix *r;
+ if(!mat)
+ return 0;
+ r = (XftMatrix *) malloc (sizeof (*r) );
+ if (!r)
+ return 0;
+ *r = *mat;
+ return r;
+}
+
+int
+XftMatrixEqual (const XftMatrix *mat1, const XftMatrix *mat2)
+{
+ if(mat1 == mat2) return True;
+ if(mat1 == 0 || mat2 == 0) return False;
+ return mat1->xx == mat2->xx &&
+ mat1->xy == mat2->xy &&
+ mat1->yx == mat2->yx &&
+ mat1->yy == mat2->yy;
+}
+
+void
+XftMatrixMultiply (XftMatrix *result, XftMatrix *a, XftMatrix *b)
+{
+ XftMatrix r;
+
+ r.xx = a->xx * b->xx + a->xy * b->yx;
+ r.xy = a->xx * b->xy + a->xy * b->yy;
+ r.yx = a->yx * b->xx + a->yy * b->yx;
+ r.yy = a->yx * b->xy + a->yy * b->yy;
+ *result = r;
+}
+
+void
+XftMatrixRotate (XftMatrix *m, double c, double s)
+{
+ XftMatrix r;
+
+ /*
+ * X Coordinate system is upside down, swap to make
+ * rotations counterclockwise
+ */
+ r.xx = c;
+ r.xy = -s;
+ r.yx = s;
+ r.yy = c;
+ XftMatrixMultiply (m, &r, m);
+}
+
+void
+XftMatrixScale (XftMatrix *m, double sx, double sy)
+{
+ XftMatrix r;
+
+ r.xx = sx;
+ r.xy = 0;
+ r.yx = 0;
+ r.yy = sy;
+ XftMatrixMultiply (m, &r, m);
+}
+
+void
+XftMatrixShear (XftMatrix *m, double sh, double sv)
+{
+ XftMatrix r;
+
+ r.xx = 1;
+ r.xy = sh;
+ r.yx = sv;
+ r.yy = 1;
+ XftMatrixMultiply (m, &r, m);
+}
diff --git a/nx-X11/lib/Xft1/xftname.c b/nx-X11/lib/Xft1/xftname.c
new file mode 100644
index 000000000..a28e32cd9
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftname.c
@@ -0,0 +1,59 @@
+/*
+ * $XFree86: xc/lib/Xft1/xftname.c,v 1.3tsi 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 <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+XftPattern *
+XftNameParse (const char *name)
+{
+ return FcNameParse ((const FcChar8 *) name);
+}
+
+
+Bool
+XftNameUnparse (XftPattern *pat, char *dest, int len)
+{
+ FcChar8 *name = FcNameUnparse (pat);
+ if (!name)
+ return FcFalse;
+ if (strlen ((char *) name) > len - 1)
+ {
+ free (name);
+ return FcFalse;
+ }
+ strcpy (dest, (char *) name);
+ free (name);
+ return FcTrue;
+}
+
+Bool
+XftNameConstant (char *string, int *result)
+{
+ return FcNameConstant ((FcChar8 *) string, result);
+}
+
diff --git a/nx-X11/lib/Xft1/xftpat.c b/nx-X11/lib/Xft1/xftpat.c
new file mode 100644
index 000000000..611144c2d
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftpat.c
@@ -0,0 +1,243 @@
+/*
+ * $XFree86: xc/lib/Xft/xftpat.c,v 1.6 2001/03/30 18:50:18 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 <stdlib.h>
+#include <string.h>
+#include "xftint.h"
+#include <fontconfig/fcprivate.h>
+
+XftPattern *
+XftPatternCreate (void)
+{
+ return FcPatternCreate ();
+}
+
+void
+XftValueDestroy (XftValue v)
+{
+ FcValueDestroy (v);
+}
+
+void
+XftPatternDestroy (XftPattern *p)
+{
+ FcPatternDestroy (p);
+}
+
+
+Bool
+XftPatternAdd (XftPattern *p, const char *object, XftValue value, Bool append)
+{
+ return FcPatternAdd (p, object, value, append);
+}
+
+Bool
+XftPatternDel (XftPattern *p, const char *object)
+{
+ return FcPatternDel (p, object);
+}
+
+Bool
+XftPatternAddInteger (XftPattern *p, const char *object, int i)
+{
+ XftValue v;
+
+ v.type = XftTypeInteger;
+ v.u.i = i;
+ return XftPatternAdd (p, object, v, True);
+}
+
+Bool
+XftPatternAddDouble (XftPattern *p, const char *object, double d)
+{
+ XftValue v;
+
+ v.type = XftTypeDouble;
+ v.u.d = d;
+ return XftPatternAdd (p, object, v, True);
+}
+
+
+Bool
+XftPatternAddString (XftPattern *p, const char *object, const char *s)
+{
+ XftValue v;
+
+ v.type = XftTypeString;
+ v.u.s = (FcChar8 *) s;
+ return XftPatternAdd (p, object, v, True);
+}
+
+Bool
+XftPatternAddMatrix (XftPattern *p, const char *object, const XftMatrix *s)
+{
+ XftValue v;
+
+ v.type = XftTypeMatrix;
+ v.u.m = (XftMatrix *) s;
+ return XftPatternAdd (p, object, v, True);
+}
+
+
+Bool
+XftPatternAddBool (XftPattern *p, const char *object, Bool b)
+{
+ XftValue v;
+
+ v.type = XftTypeBool;
+ v.u.b = b;
+ return XftPatternAdd (p, object, v, True);
+}
+
+XftResult
+XftPatternGet (XftPattern *p, const char *object, int id, XftValue *v)
+{
+ return FcPatternGet (p, object, id, v);
+}
+
+XftResult
+XftPatternGetInteger (XftPattern *p, const char *object, int id, int *i)
+{
+ XftValue v;
+ XftResult r;
+
+ r = XftPatternGet (p, object, id, &v);
+ if (r != XftResultMatch)
+ return r;
+ switch (v.type) {
+ case XftTypeDouble:
+ *i = (int) v.u.d;
+ break;
+ case XftTypeInteger:
+ *i = v.u.i;
+ break;
+ default:
+ return XftResultTypeMismatch;
+ }
+ return XftResultMatch;
+}
+
+XftResult
+XftPatternGetDouble (XftPattern *p, const char *object, int id, double *d)
+{
+ XftValue v;
+ XftResult r;
+
+ r = XftPatternGet (p, object, id, &v);
+ if (r != XftResultMatch)
+ return r;
+ switch (v.type) {
+ case XftTypeDouble:
+ *d = v.u.d;
+ break;
+ case XftTypeInteger:
+ *d = (double) v.u.i;
+ break;
+ default:
+ return XftResultTypeMismatch;
+ }
+ return XftResultMatch;
+}
+
+XftResult
+XftPatternGetString (XftPattern *p, const char *object, int id, char **s)
+{
+ XftValue v;
+ XftResult r;
+
+ r = XftPatternGet (p, object, id, &v);
+ if (r != XftResultMatch)
+ return r;
+ if (v.type != XftTypeString)
+ return XftResultTypeMismatch;
+ *s = (char *) v.u.s;
+ return XftResultMatch;
+}
+
+XftResult
+XftPatternGetMatrix (XftPattern *p, const char *object, int id, XftMatrix **m)
+{
+ XftValue v;
+ XftResult r;
+
+ r = XftPatternGet (p, object, id, &v);
+ if (r != XftResultMatch)
+ return r;
+ if (v.type != XftTypeMatrix)
+ return XftResultTypeMismatch;
+ *m = (XftMatrix *) v.u.m;
+ return XftResultMatch;
+}
+
+
+XftResult
+XftPatternGetBool (XftPattern *p, const char *object, int id, Bool *b)
+{
+ XftValue v;
+ XftResult r;
+
+ r = XftPatternGet (p, object, id, &v);
+ if (r != XftResultMatch)
+ return r;
+ if (v.type != XftTypeBool)
+ return XftResultTypeMismatch;
+ *b = v.u.b;
+ return XftResultMatch;
+}
+
+XftPatternElt *
+XftPatternFind (XftPattern *p, const char *object, FcBool insert)
+{
+ if (insert)
+ return FcPatternInsertElt (p, object);
+ else
+ return FcPatternFindElt (p, object);
+}
+
+
+XftPattern *
+XftPatternDuplicate (XftPattern *orig)
+{
+ return FcPatternDuplicate (orig);
+}
+
+XftPattern *
+XftPatternVaBuild (XftPattern *orig, va_list va)
+{
+ XftPattern *ret;
+
+ FcPatternVapBuild (ret, orig, va);
+ return ret;
+}
+
+XftPattern *
+XftPatternBuild (XftPattern *orig, ...)
+{
+ va_list va;
+
+ va_start (va, orig);
+ FcPatternVapBuild (orig, orig, va);
+ va_end (va);
+ return orig;
+}
diff --git a/nx-X11/lib/Xft1/xftrender.c b/nx-X11/lib/Xft1/xftrender.c
new file mode 100644
index 000000000..419ae9f8a
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftrender.c
@@ -0,0 +1,527 @@
+/*
+ * $XFree86: xc/lib/Xft/xftrender.c,v 1.8 2001/07/13 18:16: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 <stdlib.h>
+#include "xftint.h"
+
+void
+XftRenderString8 (Display *dpy, Picture src,
+ XftFontStruct *font, Picture dst,
+ int srcx, int srcy,
+ int x, int y,
+ XftChar8 *string, int len)
+{
+ XftChar32 missing[XFT_NMISSING];
+ int nmissing;
+ XftChar8 *s;
+ int l;
+
+ s = string;
+ l = len;
+ nmissing = 0;
+ while (l--)
+ XftGlyphCheck (dpy, font, (XftChar32) *s++, missing, &nmissing);
+ if (nmissing)
+ XftGlyphLoad (dpy, font, missing, nmissing);
+ XRenderCompositeString8 (dpy, PictOpOver, src, dst,
+ font->format, font->glyphset,
+ srcx, srcy, x, y, (char *) string, len);
+}
+
+void
+XftRenderString16 (Display *dpy, Picture src,
+ XftFontStruct *font, Picture dst,
+ int srcx, int srcy,
+ int x, int y,
+ XftChar16 *string, int len)
+{
+ XftChar32 missing[XFT_NMISSING];
+ int nmissing;
+ XftChar16 *s;
+ int l;
+
+ s = string;
+ l = len;
+ nmissing = 0;
+ while (l--)
+ XftGlyphCheck (dpy, font, (XftChar32) *s++, missing, &nmissing);
+ if (nmissing)
+ XftGlyphLoad (dpy, font, missing, nmissing);
+ XRenderCompositeString16 (dpy, PictOpOver, src, dst,
+ font->format, font->glyphset,
+ srcx, srcy, x, y, string, len);
+}
+
+void
+XftRenderString32 (Display *dpy, Picture src,
+ XftFontStruct *font, Picture dst,
+ int srcx, int srcy,
+ int x, int y,
+ XftChar32 *string, int len)
+{
+ XftChar32 missing[XFT_NMISSING];
+ int nmissing;
+ XftChar32 *s;
+ int l;
+
+ s = string;
+ l = len;
+ nmissing = 0;
+ while (l--)
+ XftGlyphCheck (dpy, font, (XftChar32) *s++, missing, &nmissing);
+ if (nmissing)
+ XftGlyphLoad (dpy, font, missing, nmissing);
+ XRenderCompositeString32 (dpy, PictOpOver, src, dst,
+ font->format, font->glyphset,
+ srcx, srcy, x, y, string, len);
+}
+
+void
+XftRenderStringUtf8 (Display *dpy, Picture src,
+ XftFontStruct *font, Picture dst,
+ int srcx, int srcy,
+ int x, int y,
+ XftChar8 *string, int len)
+{
+ XftChar8 *s;
+ XftChar32 c;
+ XftChar32 lbuf[4096];
+ XftChar32 *d;
+ XftChar8 *dst8;
+ XftChar16 *dst16;
+ XftChar32 *dst32;
+ int rlen, clen;
+ int width = 1;
+ int n;
+
+ /* compute needed width */
+ if (!XftUtf8Len (string, len, &n, &width))
+ return;
+
+ d = lbuf;
+ if (n * width > sizeof (lbuf))
+ {
+ d = (XftChar32 *) malloc (n * width);
+ if (!d)
+ return;
+ }
+
+ switch (width) {
+ case 4:
+ s = string;
+ rlen = len;
+ dst32 = d;
+ while (rlen)
+ {
+ clen = XftUtf8ToUcs4 (s, &c, rlen);
+ if (clen <= 0) /* malformed UTF8 string */
+ return;
+ *dst32++ = c;
+ s += clen;
+ rlen -= clen;
+ }
+ dst32 = d;
+ XftRenderString32 (dpy, src, font, dst, srcx, srcy, x, y,
+ dst32, n);
+ break;
+ case 2:
+ s = string;
+ rlen = len;
+ dst16 = (XftChar16 *) d;
+ while (rlen)
+ {
+ clen = XftUtf8ToUcs4 (s, &c, rlen);
+ if (clen <= 0) /* malformed UTF8 string */
+ return;
+ *dst16++ = c;
+ s += clen;
+ rlen -= clen;
+ }
+ dst16 = (XftChar16 *) d;
+ XftRenderString16 (dpy, src, font, dst, srcx, srcy, x, y,
+ dst16, n);
+ break;
+ case 1:
+ s = string;
+ rlen = len;
+ dst8 = (XftChar8 *) d;
+ while (rlen)
+ {
+ clen = XftUtf8ToUcs4 (s, &c, rlen);
+ if (clen <= 0) /* malformed UTF8 string */
+ return;
+ *dst8++ = c;
+ s += clen;
+ rlen -= clen;
+ }
+ dst8 = (XftChar8 *) d;
+ XftRenderString8 (dpy, src, font, dst, srcx, srcy, x, y,
+ dst8, n);
+ break;
+ }
+ if (d != lbuf)
+ free (d);
+}
+
+void
+XftRenderExtents8 (Display *dpy,
+ XftFontStruct *font,
+ XftChar8 *string,
+ int len,
+ XGlyphInfo *extents)
+{
+ XftChar32 missing[XFT_NMISSING];
+ int nmissing;
+ XftChar8 *s, c;
+ int l;
+ XGlyphInfo *gi;
+ int x, y;
+ int left, right, top, bottom;
+ int overall_left, overall_right;
+ int overall_top, overall_bottom;
+
+ s = string;
+ l = len;
+ nmissing = 0;
+ while (l--)
+ XftGlyphCheck (dpy, font, (XftChar32) *s++, missing, &nmissing);
+ if (nmissing)
+ XftGlyphLoad (dpy, font, missing, nmissing);
+
+ gi = 0;
+ while (len)
+ {
+ c = *string++;
+ len--;
+ gi = c < font->nrealized ? font->realized[c] : 0;
+ if (gi)
+ break;
+ }
+ if (len == 0 && !gi)
+ {
+ extents->width = 0;
+ extents->height = 0;
+ extents->x = 0;
+ extents->y = 0;
+ extents->yOff = 0;
+ extents->xOff = 0;
+ return;
+ }
+ x = 0;
+ y = 0;
+ overall_left = x - gi->x;
+ overall_top = y - gi->y;
+ overall_right = overall_left + (int) gi->width;
+ overall_bottom = overall_top + (int) gi->height;
+ x += gi->xOff;
+ y += gi->yOff;
+ while (len--)
+ {
+ c = *string++;
+ gi = c < font->nrealized ? font->realized[c] : 0;
+ if (!gi)
+ continue;
+ left = x - gi->x;
+ top = y - gi->y;
+ right = left + (int) gi->width;
+ bottom = top + (int) gi->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 += gi->xOff;
+ y += gi->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;
+}
+
+void
+XftRenderExtents16 (Display *dpy,
+ XftFontStruct *font,
+ XftChar16 *string,
+ int len,
+ XGlyphInfo *extents)
+{
+ XftChar32 missing[XFT_NMISSING];
+ int nmissing;
+ XftChar16 *s, c;
+ int l;
+ XGlyphInfo *gi;
+ int x, y;
+ int left, right, top, bottom;
+ int overall_left, overall_right;
+ int overall_top, overall_bottom;
+
+ s = string;
+ l = len;
+ nmissing = 0;
+ while (l--)
+ XftGlyphCheck (dpy, font, (XftChar32) *s++, missing, &nmissing);
+ if (nmissing)
+ XftGlyphLoad (dpy, font, missing, nmissing);
+
+ gi = 0;
+ while (len)
+ {
+ c = *string++;
+ len--;
+ gi = c < font->nrealized ? font->realized[c] : 0;
+ if (gi)
+ break;
+ }
+ if (len == 0 && !gi)
+ {
+ extents->width = 0;
+ extents->height = 0;
+ extents->x = 0;
+ extents->y = 0;
+ extents->yOff = 0;
+ extents->xOff = 0;
+ return;
+ }
+ x = 0;
+ y = 0;
+ overall_left = x - gi->x;
+ overall_top = y - gi->y;
+ overall_right = overall_left + (int) gi->width;
+ overall_bottom = overall_top + (int) gi->height;
+ x += gi->xOff;
+ y += gi->yOff;
+ while (len--)
+ {
+ c = *string++;
+ gi = c < font->nrealized ? font->realized[c] : 0;
+ if (!gi)
+ continue;
+ left = x - gi->x;
+ top = y - gi->y;
+ right = left + (int) gi->width;
+ bottom = top + (int) gi->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 += gi->xOff;
+ y += gi->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;
+}
+
+void
+XftRenderExtents32 (Display *dpy,
+ XftFontStruct *font,
+ XftChar32 *string,
+ int len,
+ XGlyphInfo *extents)
+{
+ XftChar32 missing[XFT_NMISSING];
+ int nmissing;
+ XftChar32 *s, c;
+ int l;
+ XGlyphInfo *gi;
+ int x, y;
+ int left, right, top, bottom;
+ int overall_left, overall_right;
+ int overall_top, overall_bottom;
+
+ s = string;
+ l = len;
+ nmissing = 0;
+ while (l--)
+ XftGlyphCheck (dpy, font, (XftChar32) *s++, missing, &nmissing);
+ if (nmissing)
+ XftGlyphLoad (dpy, font, missing, nmissing);
+
+ gi = 0;
+ while (len)
+ {
+ c = *string++;
+ len--;
+ gi = c < font->nrealized ? font->realized[c] : 0;
+ if (gi)
+ break;
+ }
+ if (len == 0 && !gi)
+ {
+ extents->width = 0;
+ extents->height = 0;
+ extents->x = 0;
+ extents->y = 0;
+ extents->yOff = 0;
+ extents->xOff = 0;
+ return;
+ }
+ x = 0;
+ y = 0;
+ overall_left = x - gi->x;
+ overall_top = y - gi->y;
+ overall_right = overall_left + (int) gi->width;
+ overall_bottom = overall_top + (int) gi->height;
+ x += gi->xOff;
+ y += gi->yOff;
+ while (len--)
+ {
+ c = *string++;
+ gi = c < font->nrealized ? font->realized[c] : 0;
+ if (!gi)
+ continue;
+ left = x - gi->x;
+ top = y - gi->y;
+ right = left + (int) gi->width;
+ bottom = top + (int) gi->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 += gi->xOff;
+ y += gi->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;
+}
+
+void
+XftRenderExtentsUtf8 (Display *dpy,
+ XftFontStruct *font,
+ XftChar8 *string,
+ int len,
+ XGlyphInfo *extents)
+{
+ XftChar32 missing[XFT_NMISSING];
+ int nmissing;
+ XftChar8 *s;
+ XftChar32 c;
+ int l, clen;
+ XGlyphInfo *gi;
+ int x, y;
+ int left, right, top, bottom;
+ int overall_left, overall_right;
+ int overall_top, overall_bottom;
+
+ s = string;
+ l = len;
+ nmissing = 0;
+ while (l)
+ {
+ clen = XftUtf8ToUcs4 (s, &c, l);
+ if (clen < 0)
+ break;
+ XftGlyphCheck (dpy, font, (XftChar32) c, missing, &nmissing);
+ s += clen;
+ l -= clen;
+ }
+ if (nmissing)
+ XftGlyphLoad (dpy, font, missing, nmissing);
+
+ gi = 0;
+ while (len)
+ {
+ clen = XftUtf8ToUcs4 (string, &c, len);
+ if (clen < 0)
+ {
+ len = 0;
+ break;
+ }
+ len -= clen;
+ string += clen;
+ gi = c < font->nrealized ? font->realized[c] : 0;
+ if (gi)
+ break;
+ }
+ if (len == 0 && !gi)
+ {
+ extents->width = 0;
+ extents->height = 0;
+ extents->x = 0;
+ extents->y = 0;
+ extents->yOff = 0;
+ extents->xOff = 0;
+ return;
+ }
+ x = 0;
+ y = 0;
+ overall_left = x - gi->x;
+ overall_top = y - gi->y;
+ overall_right = overall_left + (int) gi->width;
+ overall_bottom = overall_top + (int) gi->height;
+ x += gi->xOff;
+ y += gi->yOff;
+ while (len)
+ {
+ clen = XftUtf8ToUcs4 (string, &c, len);
+ if (clen < 0)
+ break;
+ len -= clen;
+ string += clen;
+ gi = c < font->nrealized ? font->realized[c] : 0;
+ if (!gi)
+ continue;
+ left = x - gi->x;
+ top = y - gi->y;
+ right = left + (int) gi->width;
+ bottom = top + (int) gi->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 += gi->xOff;
+ y += gi->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;
+}
diff --git a/nx-X11/lib/Xft1/xftstr.c b/nx-X11/lib/Xft1/xftstr.c
new file mode 100644
index 000000000..af6013764
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftstr.c
@@ -0,0 +1,259 @@
+/*
+ * $XFree86: xc/lib/Xft/xftstr.c,v 1.6 2001/04/01 14:00:01 tsi 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 <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include "xftint.h"
+
+char *
+_XftSaveString (const char *s)
+{
+ char *r;
+
+ if (!s)
+ return 0;
+ r = (char *) malloc (strlen (s) + 1);
+ if (!r)
+ return 0;
+ strcpy (r, s);
+ return r;
+}
+
+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;
+}
+
+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;
+}
+
+char *
+_XftDownStr (const char *field, char *save)
+{
+ char *s = save;
+ char c;
+
+ while (*field)
+ {
+ c = *field++;
+ *save++ = c;
+ }
+ *save = 0;
+ return s;
+}
+
+const char *
+_XftSplitField (const char *field, char *save)
+{
+ char c;
+
+ while (*field)
+ {
+ if (*field == '-' || *field == '=')
+ break;
+ c = *field++;
+ *save++ = c;
+ }
+ *save = 0;
+ return field;
+}
+
+const char *
+_XftSplitValue (const char *field, char *save)
+{
+ char c;
+
+ while (*field)
+ {
+ if (*field == '-' || *field == ',')
+ break;
+ c = *field++;
+ *save++ = c;
+ }
+ *save = 0;
+ if (*field)
+ field++;
+ return field;
+}
+
+int
+_XftMatchSymbolic (XftSymbolic *s, int n, const char *name, int def)
+{
+ while (n--)
+ {
+ if (!_XftStrCmpIgnoreCase (s->name, name))
+ return s->value;
+ s++;
+ }
+ return def;
+}
+
+int
+_XftStrCmpIgnoreCase (const char *s1, const char *s2)
+{
+ char c1, c2;
+
+ for (;;)
+ {
+ c1 = *s1++;
+ c2 = *s2++;
+ if (!c1 || !c2)
+ break;
+ if (isupper (c1))
+ c1 = tolower (c1);
+ if (isupper (c2))
+ c2 = tolower (c2);
+ if (c1 != c2)
+ break;
+ }
+ return (int) c2 - (int) c1;
+}
+
+int
+XftUtf8ToUcs4 (XftChar8 *src_orig,
+ XftChar32 *dst,
+ int len)
+{
+ XftChar8 *src = src_orig;
+ XftChar8 s;
+ int extra;
+ XftChar32 result;
+
+ if (len == 0)
+ return 0;
+
+ s = *src++;
+ len--;
+
+ if (!(s & 0x80))
+ {
+ result = s;
+ extra = 0;
+ }
+ else if (!(s & 0x40))
+ {
+ return -1;
+ }
+ else if (!(s & 0x20))
+ {
+ result = s & 0x1f;
+ extra = 1;
+ }
+ else if (!(s & 0x10))
+ {
+ result = s & 0xf;
+ extra = 2;
+ }
+ else if (!(s & 0x08))
+ {
+ result = s & 0x07;
+ extra = 3;
+ }
+ else if (!(s & 0x04))
+ {
+ result = s & 0x03;
+ extra = 4;
+ }
+ else if ( ! (s & 0x02))
+ {
+ result = s & 0x01;
+ extra = 5;
+ }
+ else
+ {
+ return -1;
+ }
+ if (extra > len)
+ return -1;
+
+ while (extra--)
+ {
+ result <<= 6;
+ s = *src++;
+
+ if ((s & 0xc0) != 0x80)
+ return -1;
+
+ result |= s & 0x3f;
+ }
+ *dst = result;
+ return src - src_orig;
+}
+
+Bool
+XftUtf8Len (XftChar8 *string,
+ int len,
+ int *nchar,
+ int *wchar)
+{
+ int n;
+ int clen;
+ int width = 1;
+ XftChar32 c;
+
+ n = 0;
+ while (len)
+ {
+ clen = XftUtf8ToUcs4 (string, &c, len);
+ if (clen <= 0) /* malformed UTF8 string */
+ return False;
+ if (c >= 0x10000)
+ width = 4;
+ else if (c >= 0x100)
+ {
+ if (width == 1)
+ width = 2;
+ }
+ string += clen;
+ len -= clen;
+ n++;
+ }
+ *nchar = n;
+ *wchar = width;
+ return True;
+}
diff --git a/nx-X11/lib/Xft1/xftxlfd.c b/nx-X11/lib/Xft1/xftxlfd.c
new file mode 100644
index 000000000..8de596b47
--- /dev/null
+++ b/nx-X11/lib/Xft1/xftxlfd.c
@@ -0,0 +1,334 @@
+/*
+ * $XFree86: xc/lib/Xft1/xftxlfd.c,v 1.1.1.1tsi 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 <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "xftint.h"
+
+static XftSymbolic XftXlfdWeights[] = {
+ { "light", XFT_WEIGHT_LIGHT },
+ { "medium", XFT_WEIGHT_MEDIUM },
+ { "regular", XFT_WEIGHT_MEDIUM },
+ { "demibold", XFT_WEIGHT_DEMIBOLD },
+ { "bold", XFT_WEIGHT_BOLD },
+ { "black", XFT_WEIGHT_BLACK },
+};
+
+#define NUM_XLFD_WEIGHTS (sizeof XftXlfdWeights/sizeof XftXlfdWeights[0])
+
+static XftSymbolic XftXlfdSlants[] = {
+ { "r", XFT_SLANT_ROMAN },
+ { "i", XFT_SLANT_ITALIC },
+ { "o", XFT_SLANT_OBLIQUE },
+};
+
+#define NUM_XLFD_SLANTS (sizeof XftXlfdSlants/sizeof XftXlfdSlants[0])
+
+XftPattern *
+XftXlfdParse (const char *xlfd_orig, Bool ignore_scalable, Bool complete)
+{
+ XftPattern *pat;
+ const char *xlfd = xlfd_orig;
+ const char *foundry;
+ const char *family;
+ const char *weight_name;
+ const char *slant;
+ const char *registry;
+ char *save;
+ char style[128];
+ 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 (ignore_scalable && !pixel)
+ return 0;
+
+ pat = XftPatternCreate ();
+ if (!pat)
+ return 0;
+
+ save = (char *) malloc (strlen (foundry) + 1);
+
+ if (!save)
+ return 0;
+
+ if (!XftPatternAddString (pat, XFT_XLFD, xlfd_orig)) goto bail;
+
+ _XftSplitStr (foundry, save);
+ if (save[0] && strcmp (save, "*") != 0)
+ if (!XftPatternAddString (pat, XFT_FOUNDRY, save)) goto bail;
+
+ _XftSplitStr (family, save);
+ if (save[0] && strcmp (save, "*") != 0)
+ if (!XftPatternAddString (pat, XFT_FAMILY, save)) goto bail;
+
+ weight_value = _XftMatchSymbolic (XftXlfdWeights, NUM_XLFD_WEIGHTS,
+ _XftSplitStr (weight_name, save),
+ XFT_WEIGHT_MEDIUM);
+ if (!XftPatternAddInteger (pat, XFT_WEIGHT, weight_value))
+ goto bail;
+
+ slant_value = _XftMatchSymbolic (XftXlfdSlants, NUM_XLFD_SLANTS,
+ _XftSplitStr (slant, save),
+ XFT_SLANT_ROMAN);
+ if (!XftPatternAddInteger (pat, XFT_SLANT, slant_value))
+ goto bail;
+
+ dpixel = (double) pixel;
+
+ if (complete)
+ {
+ /*
+ * Build a style name
+ */
+ style[0] = '\0';
+ switch (weight_value) {
+ case XFT_WEIGHT_LIGHT: strcat (style, "light"); break;
+ case XFT_WEIGHT_DEMIBOLD: strcat (style, "demibold"); break;
+ case XFT_WEIGHT_BOLD: strcat (style, "bold"); break;
+ case XFT_WEIGHT_BLACK: strcat (style, "black"); break;
+ }
+ if (slant_value != XFT_SLANT_ROMAN) {
+ if (style[0])
+ strcat (style, " ");
+ switch (slant_value) {
+ case XFT_SLANT_ITALIC: strcat (style, "italic"); break;
+ case XFT_SLANT_OBLIQUE: strcat (style, "oblique"); break;
+ }
+ }
+ if (!style[0])
+ strcat (style, "Regular");
+
+ if (!XftPatternAddString (pat, XFT_STYLE, style))
+ goto bail;
+ if (!XftPatternAddBool (pat, XFT_SCALABLE, pixel == 0)) goto bail;
+ if (!XftPatternAddBool (pat, XFT_CORE, True)) goto bail;
+ if (!XftPatternAddBool (pat, XFT_ANTIALIAS, False)) goto bail;
+ }
+ else
+ {
+ if (point > 0)
+ {
+ if (!XftPatternAddDouble (pat, XFT_SIZE, ((double) point) / 10.0)) goto bail;
+ if (pixel <= 0 && resy > 0)
+ {
+ dpixel = (double) point * (double) resy / 720.0;
+ }
+ }
+ }
+
+ if (dpixel > 0)
+ if (!XftPatternAddDouble (pat, XFT_PIXEL_SIZE, dpixel)) goto bail;
+
+ _XftDownStr (registry, save);
+ if (registry[0] && !strchr (registry, '*'))
+ if (!XftPatternAddString (pat, XFT_ENCODING, save)) goto bail;
+
+ free (save);
+ return pat;
+
+bail:
+ free (save);
+ XftPatternDestroy (pat);
+ return 0;
+}
+
+Bool
+XftCoreAddFonts (XftFontSet *set, Display *dpy, Bool ignore_scalable)
+{
+ char **xlfds;
+ int num;
+ int i;
+ XftPattern *font;
+ Bool ret;
+
+ xlfds = XListFonts (dpy,
+ "-*-*-*-*-*-*-*-*-*-*-*-*-*-*",
+ 10000, &num);
+ if (!xlfds)
+ return False;
+ ret = True;
+ for (i = 0; ret && i < num; i++)
+ {
+ font = XftXlfdParse (xlfds[i], ignore_scalable, True);
+ if (font)
+ {
+ if (!XftFontSetAdd (set, font))
+ {
+ XftPatternDestroy (font);
+ ret = False;
+ }
+ }
+ }
+ XFreeFontNames (xlfds);
+ return ret;
+}
+
+typedef struct _XftCoreFont {
+ struct _XftCoreFont *next;
+ int ref;
+
+ XFontStruct *font;
+ Display *display;
+ char *xlfd;
+} XftCoreFont;
+
+static XftCoreFont *_XftCoreFonts;
+
+XFontStruct*
+XftCoreOpen (Display *dpy, XftPattern *pattern)
+{
+ XftCoreFont *cf;
+ char *xlfd;
+ char *xlfd_pixel = 0;
+ char *i, *o;
+ int d;
+ Bool scalable;
+ double pixel_size;
+ int pixel_int;
+ XFontStruct *ret;
+
+#if 0
+ printf ("Core ");
+ XftPatternPrint (pattern);
+#endif
+ if (XftPatternGetString (pattern, XFT_XLFD, 0, &xlfd) != XftResultMatch)
+ return 0;
+ if (XftPatternGetBool (pattern, XFT_SCALABLE, 0, &scalable) != XftResultMatch)
+ return 0;
+ if (scalable)
+ {
+ if (XftPatternGetDouble (pattern, XFT_PIXEL_SIZE, 0, &pixel_size) != XftResultMatch)
+ return 0;
+ pixel_int = (int) (pixel_size + 0.5);
+ if (pixel_int)
+ {
+ xlfd_pixel = (char *) malloc (strlen (xlfd) + 32);
+ i = xlfd;
+ o = xlfd_pixel;
+ d = 0;
+ while (d != 7 && *i)
+ {
+ if ((*o++ = *i++) == '-')
+ d++;
+ }
+ if (*i)
+ {
+ sprintf (o, "%d", pixel_int);
+ o += strlen (o);
+ while (*i != '-')
+ ++i;
+ }
+ while ((*o++ = *i++));
+#if 0
+ printf ("original %s sized %s\n", xlfd, xlfd_pixel);
+#endif
+ xlfd = xlfd_pixel;
+ }
+ }
+ for (cf = _XftCoreFonts; cf; cf = cf->next)
+ {
+ if (cf->display == dpy &&
+ !_XftStrCmpIgnoreCase (cf->xlfd, xlfd))
+ {
+ cf->ref++;
+ if (_XftFontDebug () & XFT_DBG_REF)
+ {
+ printf ("Xlfd \"%s\" matches existing font (%d)\n",
+ xlfd, cf->ref);
+ }
+ break;
+ }
+ }
+ if (!cf)
+ {
+ ret = XLoadQueryFont (dpy, xlfd);
+ if (!ret)
+ return 0;
+
+ cf = (XftCoreFont *) malloc (sizeof (XftCoreFont) +
+ strlen (xlfd) + 1);
+ if (!cf)
+ {
+ XFreeFont (dpy, ret);
+ return 0;
+ }
+
+ if (_XftFontDebug () & XFT_DBG_REF)
+ printf ("Xlfd \"%s\" matches new font\n", xlfd);
+
+ cf->next = _XftCoreFonts;
+ _XftCoreFonts = cf;
+ cf->ref = 1;
+
+ cf->font = ret;
+ cf->xlfd = (char *) (cf + 1);
+ strcpy (cf->xlfd, xlfd);
+ }
+ if (xlfd_pixel)
+ free (xlfd_pixel);
+ return cf->font;
+}
+
+void
+XftCoreClose (Display *dpy, XFontStruct *font)
+{
+ XftCoreFont *cf, **prev;
+
+ for (prev = &_XftCoreFonts; (cf = *prev); prev = &cf->next)
+ {
+ if (cf->display == dpy && cf->font == font)
+ {
+ if (--cf->ref == 0)
+ {
+ XFreeFont (dpy, cf->font);
+ *prev = cf->next;
+ free (cf);
+ }
+ break;
+ }
+ }
+}
--
cgit v1.2.3