scx/c/xlib/property.c

#include "xlib.h"
#include "scheme48.h"


/* Should be used with care */

s48_value scx_Intern_Atom (s48_value Xdisplay, s48_value name){
  Atom a = XInternAtom(SCX_EXTRACT_DISPLAY(Xdisplay), 
		       s48_extract_string(name), 0);
  return SCX_ENTER_ATOM(a);
}

s48_value scx_Find_Atom (s48_value Xdisplay, s48_value name){
  Atom a = XInternAtom (SCX_EXTRACT_DISPLAY(Xdisplay), 
			s48_extract_string(name), 1);
  return SCX_ENTER_ATOM(a);
}

s48_value scx_Atom_Name (s48_value Xdisplay, s48_value a) {
    char* s;
    // not used: Disalbe_Interrupts
    s = XGetAtomName (SCX_EXTRACT_DISPLAY(Xdisplay),
		      s48_extract_integer(a));
    // not used: Enable_Interrupts
    return s48_enter_string (s);
}

s48_value scx_List_Properties (s48_value Xwindow, s48_value Xdisplay){
    int n, i;
    Atom *ap;
    s48_value v = S48_FALSE;
    S48_DECLARE_GC_PROTECT(1);
    //not used: Disable_Interrupts
    ap = XListProperties (SCX_EXTRACT_DISPLAY(Xdisplay), 
			  SCX_EXTRACT_WINDOW(Xwindow), &n);
    //not used: Enable_Interrupts
    v = s48_make_vector (n, S48_NULL);
    S48_GC_PROTECT_1 (v);
    for (i = 0; i < n; i++) {
      S48_VECTOR_SET(v, i, s48_enter_integer((long) ap[i]));
    }
    S48_GC_UNPROTECT();
    XFree ((char *)ap);
    return v;
}


s48_value scx_Get_Property(s48_value Xwindow, s48_value Xdisplay, 
			   s48_value Xatom_prop,
			   s48_value Xatom_type, s48_value start,
			   s48_value len, s48_value deletep) {
  // Assumes short is 16 bits and int is 32 bits!
  
  Atom req_type = S48_FALSE_P(Xatom_prop) ? AnyPropertyType
    : SCX_EXTRACT_ATOM(Xatom_type);

  Atom actual_type_ret;
  int format_ret, i;
  unsigned long nitems_ret, bytes_left_ret;
  unsigned char* prop_ret = NULL;

  s48_value ret = S48_FALSE, x = S48_FALSE, v = S48_FALSE;

  S48_DECLARE_GC_PROTECT(3);

  //not used: Disable_Interrupts
  if (XGetWindowProperty (SCX_EXTRACT_DISPLAY(Xdisplay), 
			  SCX_EXTRACT_WINDOW(Xwindow),
			  s48_extract_integer(Xatom_prop), 
			  s48_extract_integer (start),
			  s48_extract_integer (len),
			  S48_EXTRACT_BOOLEAN(deletep), 
			  req_type, &actual_type_ret, &format_ret, &nitems_ret,
			  &bytes_left_ret, &prop_ret) == Success) {

    // Create the data as a vector
    S48_GC_PROTECT_3 (ret, v, x);

    v = s48_make_vector(nitems_ret, S48_FALSE);
    for (i = 0; i < nitems_ret; i++) {
      switch (format_ret) {
      case 8: x = s48_enter_fixnum(((unsigned char*) prop_ret)[i]); break;
      case 16: x = s48_enter_fixnum(((short*) prop_ret)[i]); break;
      case 32: x = s48_enter_integer(((long*) prop_ret)[i]); break;
      }
      S48_VECTOR_SET(v, i, x);
    }

    ret = s48_cons(s48_enter_integer(bytes_left_ret), S48_NULL);
    ret = s48_cons(v, ret);
    ret = s48_cons(s48_enter_integer(format_ret), ret);
    ret = s48_cons(SCX_ENTER_ATOM(actual_type_ret), ret);

    S48_GC_UNPROTECT();
  } else {
    // Property does not exists
    ret = S48_FALSE;
  }

  if (prop_ret != NULL)
    XFree(prop_ret);

  return ret;
}


s48_value scx_Change_Property(s48_value Xdisplay, s48_value Xwindow,
			      s48_value Xatom_prop,  s48_value Xatom_type,
			      s48_value format, s48_value mode, 
			      s48_value data) {
  long i, x;
  int f = (int)s48_extract_integer(format);
  int m = s48_extract_integer(mode);
  int nitems = S48_VECTOR_LENGTH(data);

  unsigned char buf[nitems * f];

  for (i = 0; i < nitems; i++) {
    x = s48_extract_integer(S48_VECTOR_REF(data, i));
    switch (f) {
    case 8: ((char*) buf)[i] = (char)x; break;
    case 16: ((short*) buf)[i] = (short)x; break;
    case 32: ((long*) buf)[i] = (long)x; break;
    }
  }

  XChangeProperty (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow),
		   SCX_EXTRACT_ATOM(Xatom_prop), SCX_EXTRACT_ATOM(Xatom_type),
		   f, m, buf, nitems);
  return S48_UNSPECIFIC;
}


s48_value scx_Delete_Property (s48_value Xdisplay, s48_value Xwindow,
			     s48_value Xatom_prop){
  XDeleteProperty (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_WINDOW(Xwindow),
		   SCX_EXTRACT_ATOM(Xatom_prop));
  return S48_UNSPECIFIC;
}


s48_value scx_Rotate_Properties (s48_value Xdisplay, s48_value Xwindow,
			     s48_value Xatom_vec, s48_value delta){
  int n = S48_VECTOR_LENGTH(Xatom_vec), i;
  Atom p[n];
  for (i = 0; i < n; i++) {
	p[i] = s48_extract_integer(S48_VECTOR_REF(Xatom_vec, i));
  }
  XRotateWindowProperties(SCX_EXTRACT_DISPLAY(Xdisplay), 
			  SCX_EXTRACT_WINDOW(Xwindow),
			  p, n,	(int)s48_extract_integer(delta));
  return S48_UNSPECIFIC;
}

s48_value scx_Set_Selection_Owner (s48_value Xdisplay, s48_value Xatom_s,
			       s48_value Xwindow_owner, s48_value time){
  
  XSetSelectionOwner (SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_ATOM(Xatom_s),
		      SCX_EXTRACT_WINDOW(Xwindow_owner), SCX_EXTRACT_TIME(time));
  return S48_UNSPECIFIC;
}


s48_value scx_Get_Selection_Owner (s48_value Xdisplay, s48_value Xatom_s){
    return SCX_ENTER_WINDOW(XGetSelectionOwner(SCX_EXTRACT_DISPLAY(Xdisplay),
					       SCX_EXTRACT_ATOM(Xatom_s)));
}


s48_value scx_Convert_Selection (s48_value Xdisplay, s48_value Xatom_s, 
			     s48_value Xatom_t, s48_value Xatom_p,
			     s48_value Xwindow, s48_value time){
   
 XConvertSelection(SCX_EXTRACT_DISPLAY(Xdisplay), SCX_EXTRACT_ATOM(Xatom_s),
		   SCX_EXTRACT_ATOM(Xatom_t), SCX_EXTRACT_ATOM(Xatom_p),
		   SCX_EXTRACT_WINDOW(Xwindow), SCX_EXTRACT_TIME(time));
 return S48_UNSPECIFIC;
}

void scx_init_property(void) {
  S48_EXPORT_FUNCTION(scx_Intern_Atom);
  S48_EXPORT_FUNCTION(scx_Find_Atom);
  S48_EXPORT_FUNCTION(scx_Atom_Name);
  S48_EXPORT_FUNCTION(scx_List_Properties);
  S48_EXPORT_FUNCTION(scx_Get_Property);
  S48_EXPORT_FUNCTION(scx_Change_Property);
  S48_EXPORT_FUNCTION(scx_Delete_Property);
  S48_EXPORT_FUNCTION(scx_Rotate_Properties);
  S48_EXPORT_FUNCTION(scx_Set_Selection_Owner);
  S48_EXPORT_FUNCTION(scx_Get_Selection_Owner);
  S48_EXPORT_FUNCTION(scx_Convert_Selection);
}