#include "reflex/ruby/pointer.h"


#include <rays/ruby/point.h>
#include "defs.h"


RUCY_DEFINE_VALUE_FROM_TO(Reflex::Pointer)

#define THIS  to<Reflex::Pointer*>(self)

#define CHECK RUCY_CHECK_OBJ(Reflex::Pointer, self)


static
VALUE alloc(VALUE klass)
{
	return new_type<Reflex::Pointer>(klass);
}

static
VALUE initialize(VALUE self, VALUE
	id, VALUE type, VALUE action, VALUE position, VALUE modifiers, VALUE click_count, VALUE drag, VALUE time)
{
	CHECK;

	*THIS = Reflex::Pointer(
		to<Reflex::Pointer::ID>(id),
		to<uint>(type),
		(Reflex::Pointer::Action) to<int>(action),
		to<Rays::Point>(position),
		to<uint>(modifiers),
		to<uint>(click_count),
		to<bool>(drag),
		to<double>(time));
	return self;
}

static
VALUE initialize_copy(VALUE self, VALUE obj)
{
	CHECK;
	*THIS = to<Reflex::Pointer&>(obj);
	return self;
}

static
VALUE get_id(VALUE self)
{
	CHECK;
	return value(THIS->id());
}

static
VALUE get_type(VALUE self)
{
	CHECK;
	return value(THIS->type());
}

static
VALUE get_action(VALUE self)
{
	CHECK;
	return value(THIS->action());
}

static
VALUE get_position(VALUE self)
{
	CHECK;
	return value(THIS->position());
}

static
VALUE get_modifiers(VALUE self)
{
	CHECK;
	return value(THIS->modifiers());
}

static
VALUE get_click_count(VALUE self)
{
	CHECK;
	return value(THIS->click_count());
}

static
VALUE is_drag(VALUE self)
{
	CHECK;
	return value(THIS->is_drag());
}

static
VALUE get_time(VALUE self)
{
	CHECK;
	return value(THIS->time());
}

static
VALUE get_prev(VALUE self)
{
	CHECK;
	return value(THIS->prev());
}


static Class cPointer;

void
Init_reflex_pointer ()
{
	Module mReflex = rb_define_module("Reflex");

	cPointer = rb_define_class_under(mReflex, "Pointer", rb_cObject);
	rb_define_alloc_func(cPointer, alloc);
	rb_define_private_method(cPointer, "initialize", RUBY_METHOD_FUNC(initialize), 8);
	rb_define_private_method(cPointer, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
	rb_define_method(cPointer, "id", RUBY_METHOD_FUNC(get_id), 0);
	rb_define_private_method(cPointer, "get_type", RUBY_METHOD_FUNC(get_type), 0);
	rb_define_private_method(cPointer, "get_action", RUBY_METHOD_FUNC(get_action), 0);
	rb_define_method(cPointer, "position", RUBY_METHOD_FUNC(get_position), 0);
	rb_define_method(cPointer, "modifiers", RUBY_METHOD_FUNC(get_modifiers), 0);
	rb_define_method(cPointer, "click_count", RUBY_METHOD_FUNC(get_click_count), 0);
	cPointer.define_method("drag?",              is_drag);
	rb_define_method(cPointer, "time", RUBY_METHOD_FUNC(get_time), 0);
	rb_define_method(cPointer, "prev", RUBY_METHOD_FUNC(get_prev), 0);
	cPointer.define_const("TYPE_NONE",    Reflex::Pointer::TYPE_NONE);
	cPointer.define_const("MOUSE",        Reflex::Pointer::MOUSE);
	cPointer.define_const("MOUSE_LEFT",   Reflex::Pointer::MOUSE_LEFT);
	cPointer.define_const("MOUSE_RIGHT",  Reflex::Pointer::MOUSE_RIGHT);
	cPointer.define_const("MOUSE_MIDDLE", Reflex::Pointer::MOUSE_MIDDLE);
	cPointer.define_const("TOUCH",        Reflex::Pointer::TOUCH);
	cPointer.define_const("PEN",          Reflex::Pointer::PEN);
	cPointer.define_const("ACTION_NONE", Reflex::Pointer::ACTION_NONE);
	cPointer.define_const("DOWN",        Reflex::Pointer::DOWN);
	cPointer.define_const("UP",          Reflex::Pointer::UP);
	cPointer.define_const("MOVE",        Reflex::Pointer::MOVE);
	cPointer.define_const("CANCEL",      Reflex::Pointer::CANCEL);
	cPointer.define_const("STAY",        Reflex::Pointer::STAY);
}


namespace Reflex
{


	Class
	pointer_class ()
	{
		return cPointer;
	}


}// Reflex