#include "xft.h"

XFT_REC_ACCESSOR_MAKER(scx_enter_xftpattern, XftPattern, scx_xftpattern_record_type);

XFT_REC_ACCESSOR_MAKER(scx_enter_xftfont, XftFont, scx_xftfont_record_type);

XFT_REC_ACCESSOR_MAKER(scx_enter_xftdraw, XftDraw, scx_xftdraw_record_type);

XFT_REC_ACCESSOR_MAKER(scx_enter_xftcolor, XftColor, scx_xftcolor_record_type);

XFT_REC_ACCESSOR_MAKER(scx_enter_xftobjectset, XftObjectSet, scx_xftobjectset_record_type);

XFT_REC_ACCESSOR_MAKER(scx_enter_xftfontset, XftFontSet, scx_xftfontset_record_type);

s48_value scx_XftPatternCreate(void) 
{
  return scx_enter_xftpattern(XftPatternCreate());
}


s48_value scx_XftPatternDestroy(s48_value sxp)
{
  XftPatternDestroy(scx_extract_xftpattern(sxp));
  return S48_UNSPECIFIC;
}

s48_value scx_XftPatternDuplicate(s48_value sxp)
{
  XftPattern *p;

  p = XftPatternDuplicate(scx_extract_xftpattern(sxp));
  return scx_enter_xftpattern(p);
}

struct xft_pattern_property* lookup_pattern_property_by_id(int id)
{
  struct xft_pattern_property *tbl;

  for (tbl = &xft_pattern_property_tbl[0]; 
       (tbl->scx_id != id) && (tbl->type != SCX_XFT_INVALID); 
       tbl++)
    ;
  return tbl;
}

s48_value scx_XftPatternGet(s48_value sxp, s48_value sobj, s48_value sid)
{
  XftPattern *p;
  XftResult rc;
  XftValue v;
  int obj, i;
  s48_value rv = S48_UNSPECIFIC;
  s48_value rl = S48_UNSPECIFIC;
  struct xft_pattern_property *tbl;
  S48_DECLARE_GC_PROTECT(5);

  S48_GC_PROTECT_5(rl, rv, sxp, sobj, sid);
  p = scx_extract_xftpattern(sxp);
  obj = s48_extract_integer(sobj);
  i = (int) s48_extract_integer(sid);

  tbl = lookup_pattern_property_by_id(obj);
  rc = XftPatternGet(p, tbl->name, i, &v);

  if ((rc != XftResultMatch) || (rc != XftResultNoMatch))
    {
      rl = s48_list_2(s48_enter_integer(rc), S48_UNSPECIFIC);
      S48_GC_UNPROTECT();
      return rl;
    }

  switch (tbl->type) {
  case SCX_XFT_STRING:
    rv = s48_enter_string(v.u.s);
    break;
  case SCX_XFT_DOUBLE:
    rv = s48_enter_double(v.u.d);
    break;
  case SCX_XFT_INT:
    rv = s48_enter_integer(v.u.i);
    break;
  case SCX_XFT_BOOL:
    rv = v.u.b ? S48_TRUE : S48_FALSE;
    break;
  case SCX_XFT_UNIMPLEMENTED:
    rv = S48_UNSPECIFIC;
    break;
  }

  rl = s48_list_2(s48_enter_integer(rc), rv);
  S48_GC_UNPROTECT();
  XftValueDestroy(v);
  return rl;
}

s48_value scx_XftPatternAdd(s48_value sxp, s48_value sobj, 
			    s48_value sval, s48_value sappend)
{
  XftPattern *p;
  XftValue v;
  int obj;
  Bool append, rv;
  struct xft_pattern_property *tbl;
  S48_DECLARE_GC_PROTECT(4);

  S48_GC_PROTECT_4(sxp, sobj, sval, sappend);
  p = scx_extract_xftpattern(sxp);
  obj = s48_extract_integer(sobj);
  append = S48_TRUE_P(sappend);
  tbl = lookup_pattern_property_by_id(sobj);

  switch (tbl->type) {
  case SCX_XFT_STRING:
    v.type = XftTypeString;
    v.u.s = s48_extract_string(sval);
    break;
  case SCX_XFT_DOUBLE:
    v.type = XftTypeDouble;
    v.u.d = s48_extract_double(sval);
    break;
  case SCX_XFT_INT:
    v.type = XftTypeInteger;
    v.u.i = s48_extract_integer(sval);
    break;
  case SCX_XFT_BOOL:
    v.type = XftTypeBool;
    v.u.b = S48_TRUE_P(sval) ? True : False;
    break;
  }
  rv = XftPatternAdd(p, tbl->name, v, append);

  S48_GC_UNPROTECT();
  return rv ? S48_TRUE : S48_FALSE;
}

s48_value scx_XftFontMatch(s48_value sdpy, s48_value sscreenno, s48_value sxp)
{
  XftPattern *p;
  XftResult r;
  S48_DECLARE_GC_PROTECT(3);
  
  S48_GC_PROTECT_3(sdpy, sscreenno, sxp);
  p = XftFontMatch((Display *) scx_extract_display(sdpy),
		   s48_extract_integer(sscreenno),
		   scx_extract_xftpattern(sxp),
		   &r);

  S48_GC_UNPROTECT();
  if (p == NULL)
  return s48_list_2(S48_FALSE, S48_UNSPECIFIC);
  else
  return s48_list_2(s48_enter_integer(r), scx_enter_xftpattern(p));
}

s48_value scx_XftFontOpenPattern(s48_value sdpy, s48_value sxp)
{
  XftFont *xf;
  S48_DECLARE_GC_PROTECT(2);

  S48_GC_PROTECT_2(sdpy, sxp);
  xf = XftFontOpenPattern(scx_extract_display(sdpy), scx_extract_xftpattern(sxp));
  S48_GC_UNPROTECT();
  return scx_enter_xftfont(xf);
}

s48_value scx_XftFontOpenName(s48_value sdpy, s48_value sscreenno, s48_value sname)
{
  XftFont *xf;
  S48_DECLARE_GC_PROTECT(3);

  S48_GC_PROTECT_3(sdpy, sscreenno, sname);
  xf = XftFontOpenName(scx_extract_display(sdpy), s48_extract_integer(sscreenno),
		       s48_extract_string(sname));
  XftPatternPrint(xf->pattern);
  S48_GC_UNPROTECT();
  return scx_enter_xftfont(xf);
}

s48_value scx_XftFontOpenXlfd(s48_value sdpy, s48_value sscreenno, s48_value sxlfd)
{
  XftFont *xf;
  S48_DECLARE_GC_PROTECT(3);

  S48_GC_PROTECT_3(sdpy, sscreenno, sxlfd);
  xf = XftFontOpenXlfd(scx_extract_display(sdpy), s48_extract_integer(sscreenno),
		       s48_extract_string(sxlfd));
  S48_GC_UNPROTECT();
  return scx_enter_xftfont(xf);
}

s48_value scx_XftFontClose(s48_value sdpy, s48_value sxf)
{
  S48_DECLARE_GC_PROTECT(2);

  S48_GC_PROTECT_2(sdpy, sxf);
  XftFontClose(scx_extract_display(sdpy),
	       scx_extract_xftfont(sxf));
  S48_GC_UNPROTECT();
  return S48_UNSPECIFIC;
}
  
s48_value scx_XftDrawCreate(s48_value sdpy, s48_value sdrawable,
			    s48_value svisual, s48_value scolormap)
{
  XftDraw *d;
  S48_DECLARE_GC_PROTECT(4);

  S48_GC_PROTECT_4(sdpy, sdrawable, svisual, scolormap);
  d = XftDrawCreate(scx_extract_display(sdpy),
		    scx_extract_drawable(sdrawable),
		    scx_extract_visual(svisual),
		    scx_extract_colormap(scolormap));
  S48_GC_UNPROTECT();
  return scx_enter_xftdraw(d);
}

s48_value scx_XftDrawCreateBitmap(s48_value sdpy, s48_value sdrawable)
{
  XftDraw *d;
  S48_DECLARE_GC_PROTECT(2);
  
  S48_GC_PROTECT_2(sdpy, sdrawable);
  d = XftDrawCreateBitmap(scx_extract_display(sdpy),
			  scx_extract_drawable(sdrawable));
  S48_GC_UNPROTECT();
  return scx_enter_xftdraw(d);
}

s48_value scx_XftDrawChange(s48_value sxd, s48_value sdrawable)
{
  S48_DECLARE_GC_PROTECT(2);

  S48_GC_PROTECT_2(sxd, sdrawable);
  XftDrawChange(scx_extract_xftdraw(sxd), 
		scx_extract_drawable(sdrawable));
  S48_GC_UNPROTECT();
  return S48_UNSPECIFIC;
}


s48_value scx_XftDrawDisplay(s48_value sxd)
{
#if SCX_XFT_VERSION > 1
  return scx_enter_display(XftDrawDisplay(scx_extract_xftdraw(sxd)));
#else
  return S48_FALSE;
#endif
}

s48_value scx_XftDrawDrawable(s48_value sxd)
{
#if SCX_XFT_VERSION > 1
  return scx_enter_drawable(XftDrawDrawabale(scx_extract_xftdraw(sxd)));
#else
  return S48_FALSE;
#endif
}

s48_value scx_XftDrawColormap(s48_value sxd)
{
#if SCX_XFT_VERSION > 1
  return scx_enter_colormap(XftDrawColormap(scx_extract_xftdraw(sxd)));
#else
  return S48_FALSE;
#endif
}

s48_value scx_XftDrawVisual(s48_value sxd)
{
#if SCX_XFT_VERSION > 1
  return scx_enter_visual(XftDrawVisual(scx_extract_xftdraw(sxd)));
#else
  return S48_FALSE;
#endif
}
  
s48_value scx_XftDrawDestroy(s48_value sxd)
{
  XftDrawDestroy(scx_extract_xftdraw(sxd));
  return S48_UNSPECIFIC;
}

s48_value scx_XftTextExtents8(s48_value sdpy, s48_value sxf, s48_value sstr)
{
  XGlyphInfo *extents;
  S48_DECLARE_GC_PROTECT(3);

  S48_GC_PROTECT_3(sdpy, sxf, sstr);
  XftTextExtents8(scx_extract_display(sdpy),
		  scx_extract_xftfont(sxf),
		  (XftChar8 *) s48_extract_string(sstr),
		  S48_STRING_LENGTH(sstr),
		  extents);

  S48_GC_UNPROTECT();
  return scx_enter_glyphinfo(extents);
}

s48_value scx_XftDrawString8(s48_value sxd, s48_value sxc,
			     s48_value sxf, s48_value sx,
			     s48_value sy, s48_value sstr)
{
  S48_DECLARE_GC_PROTECT(6);

  S48_GC_PROTECT_6(sxd, sxc, sxf, sx, sy, sstr);
  XftDrawString8(scx_extract_xftdraw(sxd), scx_extract_xftcolor(sxc),
		 scx_extract_xftfont(sxf), 
		 s48_extract_integer(sx), s48_extract_integer(sy), 
		 (XftChar8 *) s48_extract_string(sstr),
		 S48_STRING_LENGTH(sstr));
  S48_GC_UNPROTECT();
  return S48_UNSPECIFIC;
}

s48_value scx_XftDrawRect(s48_value sxd, s48_value sxc,
			  s48_value sx, s48_value sy,
			  s48_value sw, s48_value sh)
{
  S48_DECLARE_GC_PROTECT(6);

  S48_GC_PROTECT_6(sxd, sxc, sx, sy, sw, sh);
  XftDrawRect(scx_extract_xftdraw(sxd), scx_extract_xftcolor(sxc),
	      s48_extract_integer(sx), s48_extract_integer(sy),
	      s48_extract_integer(sw), s48_extract_integer(sh));
  S48_GC_UNPROTECT();
  return S48_UNSPECIFIC;
}

s48_value scx_XftDrawSetClip(s48_value sxd, s48_value sreg)
{
  Bool b;
  S48_DECLARE_GC_PROTECT(2);
  
  S48_GC_PROTECT_2(sxd, sreg);
  b = XftDrawSetClip(scx_extract_xftdraw(sxd), scx_extract_region(sreg));
  S48_GC_UNPROTECT();
  return b ? S48_TRUE : S48_FALSE;
}

s48_value scx_XftObjectSetCreate(void)
{
  return scx_enter_xftobjectset(XftObjectSetCreate());
}

s48_value scx_XftObjectSetDestroy(s48_value sxo)
{
  XftObjectSetDestroy(scx_extract_xftobjectset(sxo));
  return S48_UNSPECIFIC;
}

s48_value scx_XftObjectSetAdd(s48_value sxo, s48_value sobj)
{
  struct xft_pattern_property *tbl;
  Bool b;
  S48_DECLARE_GC_PROTECT(2);

  S48_GC_PROTECT_2(sxo, sobj);
  tbl = lookup_pattern_property_by_id(s48_extract_integer(sobj));
  b = XftObjectSetAdd(scx_extract_xftobjectset(sxo), tbl->name);
  S48_GC_UNPROTECT();
  return b ? S48_TRUE : S48_FALSE;
}

s48_value scx_XftListFontsPatternObjects(s48_value sdpy, s48_value sscreenno,
					 s48_value sxp, s48_value sxo)
{
  XftFontSet *fs;
  S48_DECLARE_GC_PROTECT(4);

  S48_GC_PROTECT_4(sdpy, sscreenno, sxp, sxo);
  fs = XftListFontsPatternObjects(scx_extract_display(sdpy),
				  s48_extract_integer(sscreenno),
				  scx_extract_xftpattern(sxp),
				  scx_extract_xftobjectset(sxo));
  S48_GC_UNPROTECT();
  return scx_enter_xftfontset(fs);
}

s48_value scx_XftFontSetCreate(void)
{
  return scx_enter_xftfontset(XftFontSetCreate());
}

s48_value scx_XftFontSetDestroy(s48_value sxfs)
{
  XftFontSetDestroy(scx_extract_xftfontset(sxfs));
  return S48_UNSPECIFIC;
}

s48_value scx_XftFontSetAdd(s48_value sxfs, s48_value sxp)
{
  Bool b;
  S48_DECLARE_GC_PROTECT(2);

  S48_GC_PROTECT_2(sxfs, sxp);
  b = XftFontSetAdd(scx_extract_xftfontset(sxfs),
		    scx_extract_xftpattern(sxp));
  S48_GC_UNPROTECT();
  return b ? S48_TRUE : S48_FALSE;
}

s48_value scx_XftColorAllocName(s48_value sdpy, s48_value svisual,
				s48_value scolormap, s48_value sname)
{
  s48_value res = S48_FALSE;
  XftColor *xftcolor;
  Bool b = False;
  S48_DECLARE_GC_PROTECT(5);

  S48_GC_PROTECT_5(res, sdpy, svisual, scolormap, sname);
  if ((xftcolor = (XftColor *) calloc(1, sizeof(XftColor))) != NULL)
    b = XftColorAllocName(scx_extract_display(sdpy), scx_extract_visual(svisual),
			  scx_extract_colormap(scolormap), s48_extract_string(sname),
			  xftcolor);
  res = s48_list_2(b ? S48_TRUE : S48_FALSE, 
		   b ? scx_enter_xftcolor(xftcolor) : S48_FALSE);
  S48_GC_UNPROTECT();
  return res;
}

s48_value scx_XftColorAllocValue(s48_value sdpy, s48_value svisual,
				 s48_value scolormap, s48_value sxrendercolor)
{
  s48_value res = S48_FALSE;
  XftColor *xftcolor = NULL;
  Bool b;
  S48_DECLARE_GC_PROTECT(5);

  S48_GC_PROTECT_5(res, sdpy, svisual, scolormap, sxrendercolor);
  b = XftColorAllocValue(scx_extract_display(sdpy), scx_extract_visual(svisual),
			 scx_extract_colormap(scolormap), 
			 scx_extract_xrendercolor(sxrendercolor),
			 xftcolor);
  res = s48_list_2(b ? S48_TRUE : S48_FALSE,
		   b ? scx_enter_xftcolor(xftcolor) : S48_FALSE);
  S48_GC_UNPROTECT();
  return res;
}

s48_value scx_XftColorFree(s48_value sdpy, s48_value svisual,
			   s48_value scolormap, s48_value sxc)
{
  S48_DECLARE_GC_PROTECT(4);

  S48_GC_PROTECT_4(sdpy, svisual, scolormap, sxc);
  XftColorFree(scx_extract_display(sdpy), scx_extract_visual(svisual),
	       scx_extract_colormap(scolormap), scx_extract_xftcolor(sxc));
  S48_GC_UNPROTECT();
  return S48_UNSPECIFIC;
}

s48_value scx_XftPatternPrint(s48_value sxp)
{
  XftPatternPrint(scx_extract_xftpattern(sxp));
  return S48_UNSPECIFIC;
}

s48_value scx_XftFontSetPrint(s48_value sxfs)
{
  XftFontSetPrint(scx_extract_xftfontset(sxfs));
  return S48_UNSPECIFIC;
}

s48_value scx_XftDefaultHasRender(s48_value sdpy)
{
  return XftDefaultHasRender(scx_extract_display(sdpy)) ? S48_TRUE : S48_FALSE;
}


void scx_xft_init(void)
{
  XFT_GC_PROTECT_IMPORT_BINDING(scx_xftpattern_record_type, "xft-pattern"); 
  XFT_GC_PROTECT_IMPORT_BINDING(scx_xftfont_record_type, "xft-font"); 
  XFT_GC_PROTECT_IMPORT_BINDING(scx_xftdraw_record_type, "xft-draw"); 
  XFT_GC_PROTECT_IMPORT_BINDING(scx_xftcolor_record_type, "xft-color"); 
  XFT_GC_PROTECT_IMPORT_BINDING(scx_xftobjectset_record_type, "xft-objectset"); 
  XFT_GC_PROTECT_IMPORT_BINDING(scx_xftfontset_record_type, "xft-fontset"); 

  SCX_EXPORT_INTEGER_TO_S48("scx-xft-result-match", scx_XftResultMatch,
			    XftResultMatch);
  SCX_EXPORT_INTEGER_TO_S48("scx-xft-result-no-match", scx_XftResultNoMatch,
			    XftResultNoMatch);
  SCX_EXPORT_INTEGER_TO_S48("scx-xft-result-type-mismatch", scx_XftResultTypeMismatch,
			    XftResultTypeMismatch);
  SCX_EXPORT_INTEGER_TO_S48("scx-xft-result-no-id", scx_XftResultNoId,
			    XftResultNoId);
  SCX_EXPORT_INTEGER_TO_S48("scx-xft-version-major", scx_XftVersionMajor,
			    SCX_XFT_VERSION_MAJOR);
  SCX_EXPORT_INTEGER_TO_S48("scx-xft-version-minor", scx_XftVersionMinor,
			    SCX_XFT_VERSION_MINOR);

  S48_EXPORT_FUNCTION(scx_XftPatternCreate);
  S48_EXPORT_FUNCTION(scx_XftPatternDestroy);
  S48_EXPORT_FUNCTION(scx_XftPatternDuplicate);
  S48_EXPORT_FUNCTION(scx_XftPatternGet);
  S48_EXPORT_FUNCTION(scx_XftPatternAdd);

  S48_EXPORT_FUNCTION(scx_XftFontMatch);
  S48_EXPORT_FUNCTION(scx_XftFontOpenPattern);
  S48_EXPORT_FUNCTION(scx_XftFontOpenName);
  S48_EXPORT_FUNCTION(scx_XftFontOpenXlfd);
  S48_EXPORT_FUNCTION(scx_XftFontClose);
  
  S48_EXPORT_FUNCTION(scx_XftDrawCreate);
  S48_EXPORT_FUNCTION(scx_XftDrawCreateBitmap);
  S48_EXPORT_FUNCTION(scx_XftDrawChange);
  S48_EXPORT_FUNCTION(scx_XftDrawDisplay);
  S48_EXPORT_FUNCTION(scx_XftDrawDrawable);
  S48_EXPORT_FUNCTION(scx_XftDrawColormap);
  S48_EXPORT_FUNCTION(scx_XftDrawVisual);
  S48_EXPORT_FUNCTION(scx_XftDrawDestroy);
  
  S48_EXPORT_FUNCTION(scx_XftTextExtents8);
  S48_EXPORT_FUNCTION(scx_XftDrawString8);
  S48_EXPORT_FUNCTION(scx_XftDrawRect);
  S48_EXPORT_FUNCTION(scx_XftDrawSetClip);

  S48_EXPORT_FUNCTION(scx_XftObjectSetCreate);
  S48_EXPORT_FUNCTION(scx_XftObjectSetDestroy);
  S48_EXPORT_FUNCTION(scx_XftObjectSetAdd);
  S48_EXPORT_FUNCTION(scx_XftListFontsPatternObjects);
  S48_EXPORT_FUNCTION(scx_XftFontSetCreate);
  S48_EXPORT_FUNCTION(scx_XftFontSetDestroy);
  S48_EXPORT_FUNCTION(scx_XftFontSetAdd);

  S48_EXPORT_FUNCTION(scx_XftColorAllocName);
  S48_EXPORT_FUNCTION(scx_XftColorAllocValue);
  S48_EXPORT_FUNCTION(scx_XftColorFree);

  S48_EXPORT_FUNCTION(scx_XftPatternPrint);
  S48_EXPORT_FUNCTION(scx_XftFontSetPrint);

  S48_EXPORT_FUNCTION(scx_XftDefaultHasRender);
}