aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/Xft1/xftdpy.c
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/lib/Xft1/xftdpy.c')
-rw-r--r--nx-X11/lib/Xft1/xftdpy.c436
1 files changed, 436 insertions, 0 deletions
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);
+ }
+}