public {
    
#include <glib.h>
#include "entity.h"
#include "js-ENodeAttrib.h"

};

package Entity;

native {

/*
 * Javascript binding for Entity
 * Copyright (c) 2000 Brian Bassett and Ian Main
 *
 * Authors: Brian Bassett <bbassett@bbassett.net>
 *	    Ian Main <imain@gtk.org>
 */

/*
 * This renderer is free software; please see the LICENSE file for
 * specific information as to licensing conditions.
 */

/*
 * $Source: /home/cvs/entity/renderers/javascript/ENode.jsi,v $
 * $Id: ENode.jsi,v 1.45 2000/08/29 07:20:45 imain Exp $
 */
};

native {


void
js_return_enode (JSVirtualMachine *js_vm, JSBuiltinInfo *js_info, 
		 JSNode *retval, ENode *node)
{
    ENodeInstanceCtx *ni;

    ni = js_calloc(js_vm, 1, sizeof(*ni));
    ni->enode = node;
    enode_ref (node);

    js_vm_builtin_create(js_vm, retval, js_info, ni);

    /* If all we ever do is call enode(), the vm will never
     * do gc otherwise.. */

    /*
    if (js_vm->gc.bytes_allocated >= js_vm->gc.trigger) {
	js_vm_garbage_collect (js_vm, retval, retval);
    }
    */
}

static void
js_return_enode_array (JSVirtualMachine *js_vm, JSNode *js_retval,
		       JSBuiltinInfo *js_info, GSList *list)
{
    ENodeInstanceCtx *ni;
    gint i = 0;
    GSList *tmp = list;
    gint len = g_slist_length (tmp);
    
    js_vm_make_array (js_vm, js_retval, len);
    
    while (tmp) {
	ENode *enode = tmp->data;
    	ni = js_calloc(js_vm, 1, sizeof(*ni));
	ni->enode = enode;
	enode_ref (enode);

	js_vm_builtin_create(js_vm, &js_retval->u.varray->data[i], 
			     js_info, ni);
	i++;
	tmp = tmp->next;
    }
}

static void
js_return_ebuf_array (JSVirtualMachine *js_vm, JSNode *js_retval,
		      GSList *list)
{
    gint i = 0;
    GSList *tmp = list;
    gint len = g_slist_length (tmp);
   
    EDEBUG (("javascript", "Creating ebuf array of length %d\n", len));
    js_vm_make_array (js_vm, js_retval, len);
    
    while (tmp) {
	EBufConst *buf = tmp->data;

	js_retval->u.varray->data[i].type = JS_STRING;
	js_vm_make_string (js_vm, &js_retval->u.varray->data[i], 
	    buf->str, buf->len);
	i++;
	tmp = tmp->next;
    }
}

static void
js_return_string_array (JSVirtualMachine *js_vm, JSNode *js_retval,
	  	        GSList *list)
{
    gint i = 0;
    GSList *tmp = list;
    gint len = g_slist_length (tmp);
    
    EDEBUG (("javascript", "Creating string array of length %d\n", len));
    js_vm_make_array (js_vm, js_retval, len);
    
    while (tmp) {
	gchar *str = tmp->data;

	js_retval->u.varray->data[i].type = JS_STRING;
	js_vm_make_string (js_vm, &js_retval->u.varray->data[i], 
			   str, strlen (str));
	i++;
	tmp = tmp->next;
    }
}



};



standard "ENode IDL (docs/ENode.idl)";


class ENode {


    native ENode *enode;

    new (string basename) {
	js_instance->enode = enode (enode_call_reference(), basename);
	enode_ref (js_instance->enode);
    };
      
    /* Base Interface */
    object function new_child (string basename) {
	
	    ENode *node = js_instance->enode;
	    ENode *new_child;

	    new_child = enode_new_child (node, basename, NULL);
	    
	    js_return_enode (js_vm, js_info, js_retval, new_child);
    };

    string property type {
	[[get]] {
    	    
    	    ENode *node = js_instance->enode;
    	    EBufConst *type;
    	    
    	    type = enode_type (node);
    	    
    	    js_retval->type = JS_STRING;
    	    js_vm_make_string (js_vm, js_retval, type->str, type->len);
	    
	};
	readonly;
	dontdelete;
	dontenum;
    };
    
    object property attrib {
	[[get]] {
	    ENodeAttribInstanceCtx *ni;
	    JSBuiltinInfo *enode_info;
	    JSNode *enode_node;

	    enode_node = &js_vm->globals[js_vm_intern(js_vm, "ENodeAttrib")];
	    enode_info = enode_node->u.vbuiltin->info;

	    ni = js_calloc(js_vm, 1, sizeof(*ni));
	    ni->enode = js_instance->enode;
	    enode_ref (ni->enode);

	    js_vm_builtin_create(js_vm, js_retval, enode_info, ni);
	};
	readonly;
	dontenum;
	dontdelete;
    };

    object property attribval {
	[[get]] {
	    ENodeAttribInstanceCtx *ni;
	    JSBuiltinInfo *enode_info;
	    JSNode *enode_node;

	    enode_node = &js_vm->globals[js_vm_intern(js_vm, "ENodeAttribVal")];
	    enode_info = enode_node->u.vbuiltin->info;

	    ni = js_calloc(js_vm, 1, sizeof(*ni));
	    ni->enode = js_instance->enode;
	    enode_ref (ni->enode);

	    js_vm_builtin_create(js_vm, js_retval, enode_info, ni);
	};
	readonly;
	dontenum;
	dontdelete;
    };

    string property path {
	[[get]] {
    
	    ENode *node = js_instance->enode;
	    EBufFreeMe *path;
	    
	    path = enode_path (node);
	    
	    js_retval->type = JS_STRING;
	    js_vm_make_string (js_vm, js_retval, path->str, path->len);
	    ebuf_free (path);

	};
	readonly;
	dontdelete;
	dontenum;
    };

    string property basename {
	[[get]] {
	
	    EBufFreeMe *basename;
	    ENode *node = js_instance->enode;
	    
	    basename = enode_basename (node);
	    
	    js_retval->type = JS_STRING;
	    js_vm_make_string (js_vm, js_retval, basename->str, basename->len);
	    ebuf_free (basename);

	};
	readonly;
	dontdelete;
	dontenum;
    };

    string property description {
	[[get]] {
	
	    ENode *node = js_instance->enode;
	    gchar *description;
	    
	    description = enode_description (node);
	    
	    if (description) {
		js_retval->type = JS_STRING;
		js_vm_make_string (js_vm, js_retval, description, strlen (description));
	    } else {
		js_retval->type = JS_NULL;
	    }
	};
	readonly;
	dontdelete;
	dontenum;
    };

    /* Node Seach Routines */
    object function parent ([string search]) {
	
	ENode *node;
	ENode *parent;

	node = js_instance->enode; 
	parent = enode_parent (node, search);	

	if (parent) {
	    js_return_enode (js_vm, js_info, js_retval, parent);
	} else {
	    js_retval->type = JS_NULL;
	}
    };


    object function child (string search) {

	ENode *node;
	ENode *child;

	node = js_instance->enode; 
	child = enode_child (node, search);	

	if (child) {
	    js_return_enode (js_vm, js_info, js_retval, child);
	} else {
	    js_retval->type = JS_NULL;
	}
    };

    object function child_rx (string regex) {

	ENode *node;
	ENode *child;

	node = js_instance->enode; 
	child = enode_child_rx (node, regex);	

	if (child) {
	    js_return_enode (js_vm, js_info, js_retval, child);
	} else {
	    js_retval->type = JS_NULL;
	}
    };

    array function children ([string search]) {

	ENode *node;
	GSList *children;

	node = js_instance->enode; 
	children = enode_children (node, search);	

	if (children) {
	    js_return_enode_array (js_vm, js_retval,
				   js_info, children);
	    g_slist_free (children);
	} else {
	    js_retval->type = JS_NULL;
	}
    };

    array function children_rx (string regex) {
	ENode *node;
	GSList *children;

	node = js_instance->enode; 
	children = enode_children_rx (node, regex);	

	if (children) {
	    js_return_enode_array (js_vm, js_retval,
				   js_info, children);
	    g_slist_free (children);
	} else {
	    js_retval->type = JS_NULL;
	}
    };

    array function children_attrib (string attrib, string attrval) {
	ENode *node;
	GSList *children;
	EBufFreeMe *eval;

	node = js_instance->enode; 
	eval = ebuf_new_with_str (attrval);
	children = enode_children_attrib (node, attrib, eval);	
	ebuf_free (eval);

	if (children) {
	    js_return_enode_array (js_vm, js_retval,
				   js_info, children);
	    g_slist_free (children);
	} else {
	    js_retval->type = JS_NULL;
	}
    };

    array function children_attrib_rx (string attrib, string regex) {
	ENode *node;
	GSList *children;

	node = js_instance->enode; 
	children = enode_children_attrib_rx (node, attrib, regex);	

	if (children) {
	    js_return_enode_array (js_vm, js_retval,
				   js_info, children);
	    g_slist_free (children);
	} else {
	    js_retval->type = JS_NULL;
	}
    };


    string function call (string function, ...) {
      
	EBufFreeMe *valret;
	GSList *call_args = NULL;
	char *fmt = NULL;

	if (js_varargc > 1) {
	    js_vm_to_string (js_vm, &js_varargv[0], &js_tempnode);
	    fmt = js_string_to_c_string (js_vm, &js_tempnode);
	    /* Advance start of varargs to next entry */
	    js_varargv = &js_varargv[1];
	    js_varargc--;
	}
	
	if (fmt) {
	    int i;
	    int n_args = strlen (fmt);

	    EDEBUG(("js-embed", "node.call: got the function name %s, argstring '%s'", 
	    	    function, fmt));

	    if (n_args != js_varargc) {
		js_vm_set_err (js_vm, "call(): argument list does not match argument count");
		js_vm_error (js_vm);
	    }
	    
	    /* We start at 1 because the fmt argument is the first real vararg */
	    for (i = 0; i < js_varargc; i++) {
		JSNode js_tempnode;
		char *str;
		int vint;

		switch(fmt[i]) {
		   
		    case 'n': 
    			EDEBUG(("js-embed", "call(): processing got an enode"));
			
			if (js_varargv[i].type == JS_BUILTIN) {
			    ENodeInstanceCtx *ni;
			    ni = js_varargv[i].u.vbuiltin->instance_context;
			    if (ni)
				call_args = enode_call_push_node(call_args, ni->enode);
			} else {
			    js_vm_set_err (js_vm, 
				"call(): argument does not match format (node not an Object)");
			    js_vm_error (js_vm);
			}
			break;

  		    /* We're just gonna make strings for all of these for now */
		    case 'e':
		    case 'b':
			js_vm_to_string (js_vm, &js_varargv[i], &js_tempnode);
			call_args = enode_call_push_data (call_args, 
							  js_tempnode.u.vstring->data, 
							  js_tempnode.u.vstring->len);
			break;	

		    case 's':
			
			js_vm_to_string (js_vm, &js_varargv[i], &js_tempnode);
			str = js_string_to_c_string (js_vm, &js_tempnode);
			call_args = enode_call_push_str (call_args, str);
			EDEBUG(("js-embed", "call(): vararg %d: string '%s'",
				i, str));
			break;	
			
		    case 'i':
			
			js_vm_to_number (js_vm, &js_varargv[i], &js_tempnode);
			vint = js_tempnode.u.vinteger;	
			call_args = enode_call_push_int (call_args, vint);
			EDEBUG(("js-embed", "call(): vararg %d: int '%d'",
				i, vint));
			break;
			
		    default:
			/* bad args string */
			enode_call_free_arg_list (call_args);
			js_vm_set_err (js_vm, "call(): Bad argument character '%s'", fmt[i]);
			js_vm_error (js_vm);
		}
	    }
	}
	
	valret = enode_call_with_list (js_instance->enode, function, call_args);
	
	if (!valret) {
	    EDEBUG(("js-embed", "call(): retval was NULL. returning none"));
	    js_retval->type = JS_NULL;
	} else {
    	    js_retval->type = JS_STRING;
    	    js_vm_make_string (js_vm, js_retval, valret->str, valret->len);
    	    ebuf_free(valret);
	}

    };

    string function attrib_quiet (string attrib, [string value]) {

	ENode *node;
	EBufConst *valret;
	EBuf *val = NULL;
	
	node = js_instance->enode;
	if (value)
	    val = ebuf_new_with_str (value);

	valret = enode_attrib_quiet (node, attrib, val);	
	
	if (valret) {
    	    js_retval->type = JS_STRING;
	    js_vm_make_string (js_vm, js_retval, valret->str, valret->len);
	} else {
	    js_retval->type = JS_NULL;
	}
    };

    boolean function attrib_is_true (string attrib) {
	js_retval->type= JS_BOOLEAN;
	js_retval->u.vboolean = enode_attrib_is_true (js_instance->enode, attrib);	
    };

    array function list_set_attribs () {
	GSList *lst;
   
	lst = enode_list_set_attribs (js_instance->enode); 

	if (lst) {
	    js_return_ebuf_array (js_vm, js_retval, lst);
	    g_slist_free (lst);
	} else {
	    js_retval->type = JS_NULL;
	}
    };

    array function supported_attribs () {
	
	GSList *lst;
   
	lst = enode_supported_attribs (js_instance->enode); 
	
	if (lst) {
	    js_return_string_array (js_vm, js_retval, lst);
	    g_slist_free (lst);
	} else {
	    js_retval->type = JS_NULL;
	}
    };

    string function attrib_description (string attrib) {
	gchar *ret;
	ret = enode_attrib_description (js_instance->enode, attrib);
	if (ret) {
    	    js_retval->type = JS_STRING;
	    js_vm_make_string (js_vm, js_retval, ret, strlen (ret));
	} else {
	    js_retval->type = JS_NULL;
	}
    };

    string function attrib_value_type (string attrib) {
	gchar *ret;
	ret = enode_attrib_value_type (js_instance->enode, attrib);
	if (ret) {
    	    js_retval->type = JS_STRING;
	    js_vm_make_string (js_vm, js_retval, ret, strlen (ret));
	} else {
	    js_retval->type = JS_NULL;
	}
    };

    string function attrib_possible_values (string attrib) {
	gchar *ret;
	ret = enode_attrib_possible_values (js_instance->enode, attrib);
	if (ret) {
    	    js_retval->type = JS_STRING;
	    js_vm_make_string (js_vm, js_retval, ret, strlen (ret));
	} else {
	    js_retval->type = JS_NULL;
	}
    };

    undefined function attribs_sync () {
	enode_attribs_sync (js_instance->enode);
    };

    undefined function destroy () {
	enode_destroy (js_instance->enode);
    };

    /* Node destruction functions */

    delete () {
	/* g_print ("deleting node %s\n", js_instance->enode->element->str); */
	enode_unref (js_instance->enode);
    };

    undefined function destroy_children () {

	ENode *node;

	node = js_instance->enode; 
	enode_destroy_children (node);	
    };

    
    /* Raw XML Interfaces */
    string function get_xml () {
	ENode *node;
	EBufFreeMe *xml;

	node = js_instance->enode; 
	xml = enode_get_xml (node);	
	if (xml) {
	    js_retval->type = JS_STRING;
	    js_vm_make_string (js_vm, js_retval, xml->str, xml->len);
	}
    };

    string function get_child_xml () {
	ENode *node;
	EBufFreeMe *xml;

	node = js_instance->enode; 
	xml = enode_get_child_xml (node);	
	if (xml) {
	    js_retval->type = JS_STRING;
	    js_vm_make_string (js_vm, js_retval, xml->str, xml->len);
	    ebuf_free (xml);
	} else {
	    js_retval->type = JS_NULL;
	}
    };

    undefined function append_xml (string xml) {
	ENode *node;
	EBuf *xmlbuf;
	node = js_instance->enode; 

	xmlbuf = ebuf_new_with_str (xml);
	enode_append_xml (node, xmlbuf);
	ebuf_free (xmlbuf);
    };

    undefined function set_data (string data) {
	EBufFreeMe *databuf;
	databuf = ebuf_new_with_data (js_tempnode.u.vstring->data,
				      js_tempnode.u.vstring->len);
	enode_set_data (js_instance->enode, databuf);
	ebuf_free (databuf);
    };

    string function get_data () {
	EBufConst *data;

	data = enode_get_data (js_instance->enode);	
	if (data) {
	    js_retval->type = JS_STRING;
	    js_vm_make_string (js_vm, js_retval, data->str, data->len);
	} else {
	    js_retval->type = JS_NULL;
	}
    };

    undefined function append_data (string data) {
	EBufFreeMe *databuf;

	databuf = ebuf_new_with_data (js_tempnode.u.vstring->data,
				      js_tempnode.u.vstring->len);
	enode_append_data (js_instance->enode, databuf);
	ebuf_free (databuf);
    };

    undefined function insert_data (int offset, string data) {
	EBufFreeMe *databuf;

	databuf = ebuf_new_with_data (js_tempnode.u.vstring->data,
				      js_tempnode.u.vstring->len);
	enode_insert_data (js_instance->enode, offset, databuf);
	ebuf_free (databuf);
    };

    undefined function delete_data (int offset, int count) {
	enode_delete_data (js_instance->enode, offset, count);
    };

};


object function enode (string basename) {

    ENode *node;
    JSBuiltinInfo *enode_info;

    node = enode (enode_call_reference(), basename);

    if (node) {
	JSNode *enode_node;
	enode_node = &js_vm->globals[js_vm_intern(js_vm, "ENode")];
	enode_info = enode_node->u.vbuiltin->info;
	js_return_enode (js_vm, enode_info, js_retval, node);
    } else {
	js_retval->type = JS_NULL;
    }
};

object function enode_rx (string regex) {

    ENode *node;
    JSBuiltinInfo *enode_info;

    node = enode_rx (enode_call_reference(), regex);

    if (node) {
	JSNode *enode_node;
	enode_node = &js_vm->globals[js_vm_intern(js_vm, "ENode")];
	enode_info = enode_node->u.vbuiltin->info;
	js_return_enode (js_vm, enode_info, js_retval, node);
    } else {
	js_retval->type = JS_NULL;
    }
};