#include "reflex/ruby/points.h"


#include <rucy.h>
#include "defs.h"


using namespace Rucy;

using Reflex::coord;


static Class cPoints;


namespace Reflex
{


	Class
	points_class ()
	{
		return cPoints;
	}


}// Reflex


namespace Rucy
{


	Value
	value (const Reflex::Points& points)
	{
		return new_type(cPoints, new Reflex::Points(points));
	}


}// Rucy


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

#define CHECK RUCY_CHECK_OBJ(self, Reflex::Points, cPoints)


static
RUBY_DEF_ALLOC(alloc, klass)
{
	return new_type<Reflex::Points>(klass);
}
RUBY_END

static
RUBY_DEFN(initialize)
{
	RUCY_CHECK_OBJ(self, Reflex::Points, cPoints);
	if (argc < 0 || 6 < argc)
		arg_count_error("Points#initialize", argc, 0, 1, 2, 3, 4, 5, 6);

	THIS->type      = (argc >= 1) ? to<int>(argv[0])   : Reflex::POINT_NONE;
	THIS->x         = (argc >= 2) ? to<coord>(argv[1]) : 0;
	THIS->y         = (argc >= 3) ? to<coord>(argv[2]) : 0;
	THIS->size      = 1;
	THIS->modifiers = (argc >= 4) ? to<uint>(argv[3])  : (uint) Reflex::MOD_NONE;
	THIS->count     = (argc >= 5) ? to<uint>(argv[4])  : 0;
	THIS->drag      = (argc >= 6) ? to<bool>(argv[5])  : false;

	return self;
}
RUBY_END

static
RUBY_DEF1(initialize_copy, obj)
{
	RUCY_CHECK_OBJ(self, Reflex::Points, cPoints);

	Reflex::Points* points = to<Reflex::Points*>(obj);
	if (!points) argument_error();

	*THIS = *points;
	return self;
}
RUBY_END

static
RUBY_DEF0(type)
{
	CHECK;
	return value(THIS->type);
}
RUBY_END

static
RUBY_DEF0(x)
{
	CHECK;
	return value(THIS->x);
}
RUBY_END

static
RUBY_DEF0(y)
{
	CHECK;
	return value(THIS->y);
}
RUBY_END

static
RUBY_DEF0(size)
{
	CHECK;
	return value(THIS->size);
}
RUBY_END

static
RUBY_DEF0(modifiers)
{
	CHECK;
	return value(THIS->modifiers);
}
RUBY_END

static
RUBY_DEF0(count)
{
	CHECK;
	return value(THIS->count);
}
RUBY_END

static
RUBY_DEF0(drag)
{
	CHECK;
	return value(THIS->drag);
}
RUBY_END


void
Init_points ()
{
	Module mReflex = define_module("Reflex");

	cPoints = mReflex.define_class("Points");
	cPoints.define_alloc_func(alloc);
	cPoints.define_private_method("initialize", initialize);
	cPoints.define_private_method("initialize_copy", initialize_copy);
	cPoints.define_method("type", type);
	cPoints.define_method("x", x);
	cPoints.define_method("y", y);
	cPoints.define_method("size", size);
	cPoints.define_method("modifiers", modifiers);
	cPoints.define_method("count", count);
	cPoints.define_method("drag", drag);
}