#ifndef lint
static char sccsid[] = "@(#)eventdict.c 9.2 88/01/19";
#endif

/*
 *    eventdict.c:	user manipulation of event fields
 *		Copyright (c) 1987 by Sun Microsystems, Inc. 
 */


#ifdef REF
#include <sys/types.h>
#include <ref/config.h>
#endif
#include "PostScript.h"
#include "input.h"

#define	ix_action	0
#define	ix_canvas	1
#define	ix_clientdata	2
#define	ix_exclusivity	3
#define	ix_interest	4
#define	ix_is_interest	5
#define	ix_is_queued	6
#define	ix_keystate	7
#define	ix_name		8
#define	ix_priority	9
#define	ix_process	10
#define	ix_serial	11
#define	ix_timestamp	12
#define	ix_xlocation	13
#define	ix_ylocation	14

static
eventaccess(e, set, value)
    register struct body   *e;
    int                     set;
    struct object  	    value;
{
    register struct execution_environment *ee = current_process;
    register struct object *optop = ee->optop;


    assert(e != 0);
    if (e->type != event_type) {
	ee->error_code = unregistered_error_code;
	return;
    }
    switch (set) {
    case GET_MAGIC(ix_action):
	*ee->optop = e->body.event.action;
	object_incref(&e->body.event.action);
	ee->optop++;
	break;
    case GET_MAGIC(ix_canvas):
	if (e->body.event.canvas == 0) {
	    clear_object(optop);
	}
	else {
	    register struct body *tmp;

	    tmp = (struct body *)
		cs_currentcanvasspare(e->body.event.canvas);
	    if (tmp->refcnt == 0)
		cv_incref((struct canvas *) tmp->body.canvas.canvas);
	    incref(tmp);
	    set_typed_bodied_object(optop, canvas_type, tmp);
	    optop->value.canvas = tmp->body.canvas.canvas;
	}
	ee->optop++;
	break;
    case GET_MAGIC(ix_clientdata):
	*optop = e->body.event.client_data;
	object_incref(optop);
	ee->optop++;
	break;
    case GET_MAGIC(ix_exclusivity):
	set_typed_object(optop, boolean_type);
	optop->value.fixed = e->body.event.is_exclusive;
	ee->optop++;
	break;
    case GET_MAGIC(ix_interest):
	if (e->body.event.interest) {
	    set_typed_bodied_object(optop, event_type, e->body.event.interest);
	    object_incref(optop);
	}
	else {
	    clear_object(optop);
	}
	ee->optop++;
	break;
    case GET_MAGIC(ix_is_interest):
	set_typed_object(optop, boolean_type);
	optop->value.fixed = e->body.event.is_interest;
	ee->optop++;
	break;
    case GET_MAGIC(ix_is_queued):
	set_typed_object(optop, boolean_type);
	optop->value.fixed = e->body.event.is_queued;
	ee->optop++;
	break;
    case GET_MAGIC(ix_keystate):
	if (e->body.event.keystate != 0) {
	    set_typed_bodied_object(optop, array_type, e->body.event.keystate);
	    optop->value.substring.length =
		e->body.event.keystate->body.array.used;
	    object_incref(optop);
	} else {
	    *optop = make_array(0);
	}
	ee->optop++;
	break;
    case GET_MAGIC(ix_name):
	*optop = e->body.event.name;
	object_incref(optop);
	ee->optop++;
	break;
    case GET_MAGIC(ix_priority):
	{
	    register fract priority;

	    priority = e->body.event.priority;
	    set_fixed_object(optop, priority);
	    ee->optop++;
	}
	break;
    case GET_MAGIC(ix_process):
	{
	    register struct body *proc;

	    if (e->body.event.process == 0)
		clear_object(optop);
	    else {
		proc = e->body.event.process->body_handle;
		set_typed_bodied_object(optop, process_type, proc);
		incref(proc);
	    }
	    ee->optop++;
	}
	break;
    case GET_MAGIC(ix_serial):
	{
	    register fract serial;

	    serial = e->body.event.serial;
	    set_fixed_object(optop, serial);
	    ee->optop++;
	}
	break;
    case GET_MAGIC(ix_timestamp):
	{
	    register fract time;

	time = e->body.event.time;
	set_fixed_object(optop, time);
	ee->optop++;
	}
	break;
    case GET_MAGIC(ix_xlocation):
	{
	    register struct fpoint *pos;
	    struct spoint cvcoords;
	    struct fpoint ret;

	    pos = &e->body.event.pos;
	    cs_screentocanvas(cs_currentcanvas(&ee->gontext),
			      cfloorfr(pos->x), cfloorfr(pos->y),
			      &cvcoords.x, &cvcoords.y);
	    cs_fritransform(&(ee->gontext),
			    fracti(cvcoords.x), fracti(cvcoords.y),
			    &(ret.x), &(ret.y));
	    set_fixed_object(optop, ret.x);
	    ee->optop++;
	}
	break;
    case GET_MAGIC(ix_ylocation):
	{
	    register struct fpoint *pos;
	    struct spoint cvcoords;
	    struct fpoint ret;

	    pos = &e->body.event.pos;
	    cs_screentocanvas(cs_currentcanvas(&ee->gontext),
			      cfloorfr(pos->x), cfloorfr(pos->y),
			      &cvcoords.x, &cvcoords.y);
	    cs_fritransform(&(ee->gontext),
			    fracti(cvcoords.x), fracti(cvcoords.y),
			    &(ret.x), &(ret.y));
	    set_fixed_object(optop, ret.y);
	    ee->optop++;
	}
	break;
    case SET_MAGIC(ix_action):
	object_decref(&e->body.event.action);
	e->body.event.action = value;
	object_incref(&value);
	break;
    case SET_MAGIC(ix_canvas):
	if ((value.type != canvas_type || !cv_is_canvas(value.value.canvas))
		&& value.type != null_type) {
	    ee->error_code = typecheck_error_code;
	    return;
	}
	if (e->body.event.is_interest) {
	    ee->error_code = invalidaccess_error_code;
	    return;
	}
	if (e->body.event.canvas)
	    cv_decref(e->body.event.canvas);
	if (value.type == null_type)
	    e->body.event.canvas = 0;
	else {
	    e->body.event.canvas =
		(struct canvas *) value.value.canvas;
	    cv_incref(e->body.event.canvas);
	}
	break;
    case SET_MAGIC(ix_clientdata):
	object_decref(&e->body.event.client_data);
	e->body.event.client_data = value;
	object_incref(&value);
	break;
    case SET_MAGIC(ix_exclusivity):
	if (value.type != boolean_type) {
	    ee->error_code = typecheck_error_code;
	    return;
	}
	e->body.event.is_exclusive = (value.value.fixed != 0);
	break;
    case SET_MAGIC(ix_name):
	object_decref(&e->body.event.name);
	e->body.event.name = value;
	object_incref(&value);
	break;
    case SET_MAGIC(ix_priority):
	{
	    register fract priority;

	    switch (value.type) {
	    case fixed_type:
		priority = value.value.fixed;
		break;
	    case real_type:
		priority = fractf(value.value.real);
		break;
	    default:
		ee->error_code = typecheck_error_code;
		return;
	    }
	    e->body.event.priority = priority;
	}
	break;
    case SET_MAGIC(ix_process):
	if (e->body.event.is_interest) {
	    ee->error_code = invalidaccess_error_code;
	    return;
	}
	switch (value.type) {
	  case process_type:
	    e->body.event.process = (body_of(&value))->body.process.env;
	    break;
	  case null_type:
	    e->body.event.process = 0;
	    break;
	  default:
	    ee->error_code = typecheck_error_code;
	    return;
	}
	break;
    case SET_MAGIC(ix_timestamp):
	if (e->body.event.is_interest) {
	    ee->error_code = invalidaccess_error_code;
	    return;
	} else {
	    register fract time;


	    switch (value.type) {
	    case fixed_type:
		time = value.value.fixed;
		break;
	    case real_type:
		time = fractf(value.value.real);
		break;
	    default:
		ee->error_code = typecheck_error_code;
		return;
	    }
	    e->body.event.time = time;
	}
	break;
    case SET_MAGIC(ix_xlocation):
	{
	    fract       x, y;
	    fract       event_y = e->body.event.pos.y;

	    switch (value.type) {
	    case fixed_type:
		cs_frtransform(&(ee->gontext),
			       value.value.fixed, event_y,
			       &x, &y);
		break;
	    case real_type:
		cs_frtransform(&(ee->gontext),
			       fractf(value.value.real), event_y,
			       &x, &y);
		break;
	    default:
		ee->error_code = typecheck_error_code;
		return;
	    }
	    cs_canvastoscreen(cs_currentcanvas(&ee->gontext), x, y,
			      &(e->body.event.pos.x), &event_y);
	}
	break;
    case SET_MAGIC(ix_ylocation):
	{
	    fract       x, y;
	    fract       event_x = e->body.event.pos.x;

	    switch (value.type) {
	    case fixed_type:
		cs_frtransform(&(ee->gontext), event_x, value.value.fixed, &x, &y);
		break;
	    case real_type:
		cs_frtransform(&(ee->gontext), event_x, fractf(value.value.real),
			       &x, &y);
		break;
	    default:
		ee->error_code = typecheck_error_code;
		return;
	    }
	    cs_canvastoscreen(cs_currentcanvas(&ee->gontext), x, y,
			      &event_x, &(e->body.event.pos.y));
	}
	break;
#ifdef	notdef
    case SET_MAGIC(ix_interest):
    case SET_MAGIC(ix_is_interest):
    case SET_MAGIC(ix_is_queued):
    case SET_MAGIC(ix_keystate):
    case SET_MAGIC(ix_serial):
#endif
    default:
	ee->error_code = invalidaccess_error_code;
	break;
    }
}

initialize_eventdict()
{
    register struct body *ed = new_dict(30);
    struct object o;

    dict_table[(int)event_type] = ed;
    ed->refcnt = maximum_refcnt;
    set_typed_bodied_object(&o, dictionary_type, ed);
    define_object(system_dictionary, "magic:eventdict", o);
    define_magic("Action", ed, eventaccess, ix_action, 0, 1);
    define_magic("Canvas", ed, eventaccess, ix_canvas, 0, 1);
    define_magic("ClientData", ed, eventaccess, ix_clientdata, 0, 1);
    define_magic("Exclusivity", ed, eventaccess, ix_exclusivity, 0, 1);
    define_magic("Interest", ed, eventaccess, ix_interest, 0, 1);
    define_magic("IsInterest", ed, eventaccess, ix_is_interest, 0, 1);
    define_magic("IsQueued", ed, eventaccess, ix_is_queued, 0, 1);
    define_magic("KeyState", ed, eventaccess, ix_keystate, 0, 1);
    define_magic("Name", ed, eventaccess, ix_name, 0, 1);
    define_magic("Priority", ed, eventaccess, ix_priority, 0, 1);
    define_magic("Process", ed, eventaccess, ix_process, 0, 1);
    define_magic("Serial", ed, eventaccess, ix_serial, 0, 1);
    define_magic("TimeStamp", ed, eventaccess, ix_timestamp, 0, 1);
    define_magic("XLocation", ed, eventaccess, ix_xlocation, 0, 1);
    define_magic("YLocation", ed, eventaccess, ix_ylocation, 0, 1);
}