#if !defined(TOONZ_PLUGIN_PARAM_TRAITS_H__)
#define TOONZ_PLUGIN_PARAM_TRAITS_H__
 
#include <toonz_params.h>
#include <functional>
 
template <typename First, typename Second>
struct param_bind_t {
	typedef First traittype;
	typedef Second realtype;
	typedef typename std::is_compound<typename First::valuetype>::value_type complextype;
	typedef typename First::valuetype valuetype;
	static const int RANGED = First::RANGED;
	static const size_t valuesize = sizeof(typename First::valuetype);
};
 
typedef param_bind_t<toonz_param_traits_double_t, TDoubleParam> tpbind_dbl_t;
typedef param_bind_t<toonz_param_traits_range_t, TRangeParam> tpbind_rng_t;
typedef param_bind_t<toonz_param_traits_color_t, TPixelParam> tpbind_col_t;
typedef param_bind_t<toonz_param_traits_point_t, TPointParam> tpbind_pnt_t;
typedef param_bind_t<toonz_param_traits_enum_t, TIntEnumParam> tpbind_enm_t;
typedef param_bind_t<toonz_param_traits_int_t, TIntParam> tpbind_int_t;
typedef param_bind_t<toonz_param_traits_bool_t, TBoolParam> tpbind_bool_t;
typedef param_bind_t<toonz_param_traits_spectrum_t, TSpectrumParam> tpbind_spc_t;
typedef param_bind_t<toonz_param_traits_string_t, TStringParam> tpbind_str_t;
typedef param_bind_t<toonz_param_traits_tonecurve_t, TToneCurveParam> tpbind_tcv_t;
 
template <typename T>
inline bool is_type_of(const toonz_param_desc_t *desc)
{
	if (desc->traits_tag == T::E)
		return true;
	return false;
}
 
/* Complex なパラメータは直接 setRangeValue() などを持たず、集約しているサブタイプを返すものがあるので、そのサブタイプを得る関数を取得する */
template <typename RT, typename F = TDoubleParamP>
inline F &get_func_a(RT *t) { assert(false); }
template <typename RT, typename F = TDoubleParamP>
inline F &get_func_b(RT *t) { assert(false); }
 
/* TRangeParam */
template <>
inline TDoubleParamP &get_func_a<TRangeParam, TDoubleParamP>(TRangeParam *t)
{
	printf("get_func_a< TRangeParam, TDoubleParamP& >(TRangeParam* t)\n");
	return std::mem_fun(&TRangeParam::getMin)(t);
}
 
template <>
inline TDoubleParamP &get_func_b<TRangeParam, TDoubleParamP>(TRangeParam *t)
//template<> std::mem_fun_ref_t< TDoubleParamP&, TRangeParam > get_func_b< TRangeParam, std::mem_fun_ref_t< TDoubleParamP&, TRangeParam > >(TRangeParam* t)
{
	printf("get_func_b< TRangeParam, TDoubleParamP& >(TRangeParam* t)\n");
	return std::mem_fun(&TRangeParam::getMax)(t);
}
 
/* TPointParam */
template <>
inline TDoubleParamP &get_func_a<TPointParam, TDoubleParamP>(TPointParam *t)
//template<> std::mem_fun_ref_t< TDoubleParamP&, TPointParam > get_func_a< TPointParam, std::mem_fun_ref_t< TDoubleParamP&, TPointParam > >(TPointParam* t)
{
	printf("get_func_a< TPointParam, TDoubleParamP& >(TPointParam* t)\n");
	return std::mem_fun(&TPointParam::getX)(t);
}
 
template <>
inline TDoubleParamP &get_func_b<TPointParam, TDoubleParamP>(TPointParam *t)
//template<> std::mem_fun_ref_t< TDoubleParamP&, TPointParam > get_func_b< TPointParam, std::mem_fun_ref_t< TDoubleParamP&, TPointParam > >(TPointParam* t)
{
	printf("get_func_b< TPointParam, TDoubleParamP& >(TPointParam* t)\n");
	return std::mem_fun(&TPointParam::getY)(t);
}
 
/* valuetype が集約型の場合、 スカラを取得するための関数 */
template <typename T, typename V>
inline V get_1st_value(const T &) {}
template <typename T, typename V>
inline V get_2nd_value(const T &) {}
 
template <>
inline double get_1st_value(const toonz_param_traits_range_t::valuetype &r) { return r.a; }
template <>
inline double get_2nd_value(const toonz_param_traits_range_t::valuetype &r) { return r.b; }
 
template <>
inline double get_1st_value(const toonz_param_traits_point_t::valuetype &p) { return p.x; }
template <>
inline double get_2nd_value(const toonz_param_traits_point_t::valuetype &p) { return p.y; }
 
template <typename Bind, typename Comp = typename std::is_compound<typename Bind::valuetype>::type, int Ranged = Bind::RANGED>
//template < int Ranged, typename Comp, typename Bind >
struct set_param_range_t {
	static bool set_param_range(Param *param, const toonz_param_desc_t *desc)
	{
		/* 範囲を持たない(Ranged == std::false_type)なら何もすることはない */
		printf("(none)set_param_range: p:%p type:%s (Comp:%s Ranged:%d)\n", param, typeid(Bind).name(), typeid(Comp).name(), Ranged);
		return false;
	}
};
 
//static_assert(std::is_compound< const char* >(), "false");
 
/* ranged complextype */
template <typename Bind>
struct set_param_range_t<Bind, std::true_type, 1> {
	static bool set_param_range(Param *param, const toonz_param_desc_t *desc)
	{
		auto smartptr = param->param();
		typename Bind::realtype *p = reinterpret_cast<typename Bind::realtype *>(smartptr.getPointer());
		if (p) {
			const typename Bind::traittype &t = *reinterpret_cast<const typename Bind::traittype *>(&desc->traits.d);
			auto subtype_a = get_func_a<typename Bind::realtype>(p);
			auto subtype_b = get_func_b<typename Bind::realtype>(p);
			auto a_minval = get_1st_value<typename Bind::valuetype, double>(t.min);
			auto a_maxval = get_2nd_value<typename Bind::valuetype, double>(t.min);
			auto b_minval = get_1st_value<typename Bind::valuetype, double>(t.max);
			auto b_maxval = get_2nd_value<typename Bind::valuetype, double>(t.max);
			printf("a->set_param_range: (%g, %g)\n", a_minval, a_maxval);
			printf("b->set_param_range: (%g, %g)\n", b_minval, b_maxval);
			(subtype_a)->setValueRange(a_minval, a_maxval);
			(subtype_b)->setValueRange(b_minval, b_maxval);
		}
		return true;
	}
};
 
/* range のとき、スライダの左と右それぞれに限界が設定できるように見えるが、そうではない.
   getMin(), getMax() の結果それぞれに range を設定できるように見えて
   実際は getMin() には (min, max) のうち min, getMax() には (min, max) のうち max しか有効でないように見える.
   このため range に対しても特殊版を用意するハメになった. */
template <>
struct set_param_range_t<tpbind_rng_t, std::true_type, 1> {
	static bool set_param_range(Param *param, const toonz_param_desc_t *desc)
	{
		auto smartptr = param->param();
		tpbind_rng_t::realtype *p = reinterpret_cast<tpbind_rng_t::realtype *>(smartptr.getPointer());
		if (p) {
			const tpbind_rng_t::traittype &t = desc->traits.rd;
			auto subtype_a = get_func_a<tpbind_rng_t::realtype>(p);
			auto subtype_b = get_func_b<tpbind_rng_t::realtype>(p);
			auto a_minval = get_1st_value<tpbind_rng_t::valuetype, double>(t.minmax);
			auto a_maxval = get_2nd_value<tpbind_rng_t::valuetype, double>(t.minmax);
			(subtype_a)->setValueRange(a_minval, a_maxval);
			(subtype_b)->setValueRange(a_minval, a_maxval);
		}
		return true;
	}
};
 
/*
template <>
struct set_param_range_t< tpbind_pnt_t, std::true_type, 1 >  {
	static bool set_param_range(Param* param, const toonz_param_desc_t* desc)
	{
		auto smartptr = param->param();
		tpbind_pnt_t::realtype* p = reinterpret_cast< tpbind_pnt_t::realtype* >(smartptr.getPointer());
		if (p) {
			const tpbind_pnt_t::traittype& t = *reinterpret_cast< const tpbind_pnt_t::traittype* >(&desc->traits.d);
			auto subtype_a = get_func_a< tpbind_pnt_t::realtype >(p);
			auto subtype_b = get_func_b< tpbind_pnt_t::realtype >(p);
			auto a_minval = get_1st_value< tpbind_pnt_t::valuetype, double >(t.min);
			auto a_maxval = get_2nd_value< tpbind_pnt_t::valuetype, double >(t.min);
			auto b_minval = get_1st_value< tpbind_pnt_t::valuetype, double >(t.max);
			auto b_maxval = get_2nd_value< tpbind_pnt_t::valuetype, double >(t.max);
			printf("a->set_param_range: pnt(%g, %g)\n", a_minval, a_maxval);
			printf("b->set_param_range: pnt(%g, %g)\n", b_minval, b_maxval);
			(subtype_a)->setValueRange(a_minval, a_maxval);
			(subtype_b)->setValueRange(b_minval, b_maxval);
		}
		return true;
	}
};
*/
 
/* ranged primitive: */
template <typename Bind>
struct set_param_range_t<Bind, std::false_type, 1> {
	static bool set_param_range(Param *param, const toonz_param_desc_t *desc)
	{
		if (!is_type_of<typename Bind::traittype>(desc))
			return false;
		auto smartptr = param->param();
		typename Bind::realtype *p = reinterpret_cast<typename Bind::realtype *>(smartptr.getPointer());
		if (p) {
			const typename Bind::traittype &t = *reinterpret_cast<const typename Bind::traittype *>(&desc->traits.d);
			printf("p(%p)->set_param_range: typeid:%s desc:%p (%p)\n", p, typeid(typename Bind::traittype).name(), desc, &desc->traits.d);
			p->setValueRange(t.min, t.max);
		}
		return true;
	}
};
 
template <typename Bind>
bool set_param_range(Param *param, const toonz_param_desc_t *desc)
{
	if (!is_type_of<typename Bind::traittype>(desc))
		return false;
	return set_param_range_t<Bind>::set_param_range(param, desc);
}
 
template <typename Bind, typename Comp = typename std::is_compound<typename Bind::valuetype>::type>
struct set_param_default_t {
	static bool set_param_default(Param *param, const toonz_param_desc_t *desc)
	{
		return false;
	}
};
 
/* Default complextype */
/* Point/Range */
template <typename Bind>
struct set_param_default_t<Bind, std::true_type> {
	static bool set_param_default(Param *param, const toonz_param_desc_t *desc)
	{
		auto smartptr = param->param();
		typename Bind::realtype *p = reinterpret_cast<typename Bind::realtype *>(smartptr.getPointer());
		if (p) {
			const typename Bind::traittype &t = *reinterpret_cast<const typename Bind::traittype *>(&desc->traits.d);
			auto subtype_a = get_func_a<typename Bind::realtype>(p);
			auto subtype_b = get_func_b<typename Bind::realtype>(p);
			auto a_defval = get_1st_value<typename Bind::valuetype, double>(t.def);
			auto b_defval = get_2nd_value<typename Bind::valuetype, double>(t.def);
			printf("a->set_param_default: double (%g, %g)\n", a_defval, b_defval);
			(subtype_a)->setDefaultValue(a_defval);
			(subtype_b)->setDefaultValue(b_defval);
		}
		return true;
	}
};
 
/* Default Color */
template <>
struct set_param_default_t<tpbind_col_t, std::true_type> {
	static bool set_param_default(Param *param, const toonz_param_desc_t *desc)
	{
		auto smartptr = param->param();
		tpbind_col_t::realtype *p = reinterpret_cast<tpbind_col_t::realtype *>(smartptr.getPointer());
		if (p) {
			const tpbind_col_t::traittype &t = *reinterpret_cast<const tpbind_col_t::traittype *>(&desc->traits.d);
			p->setDefaultValue(TPixel32(t.def.c0, t.def.c1, t.def.c2, t.def.m));
		}
		return true;
	}
};
 
/* Default String */
template <>
struct set_param_default_t<tpbind_str_t, std::true_type> {
	static bool set_param_default(Param *param, const toonz_param_desc_t *desc)
	{
		auto smartptr = param->param();
		tpbind_str_t::realtype *p = reinterpret_cast<tpbind_str_t::realtype *>(smartptr.getPointer());
		if (p) {
			const tpbind_str_t::traittype &t = *reinterpret_cast<const tpbind_str_t::traittype *>(&desc->traits.d);
			printf("a->set_param_default: str\n");
			std::wstring wstr = QString::fromStdString(t.def).toStdWString();
			p->setDefaultValue(wstr);
			p->setValue(wstr, false);
		}
		return true;
	}
};
 
/* Default Spectrum */
template <>
struct set_param_default_t<tpbind_spc_t, std::true_type> {
	static bool set_param_default(Param *param, const toonz_param_desc_t *desc)
	{
		/* unfortunatly, TSpectrumParam's default values must be set within the constructor, for now.
		 see param_factory_< TSpectrumParam >() */
		return false;
	}
};
 
/* Default ToneCurve */
template <>
struct set_param_default_t<tpbind_tcv_t, std::true_type> {
	static bool set_param_default(Param *param, const toonz_param_desc_t *desc)
	{
		/*
		auto smartptr = param->param();
		tpbind_tcv_t::realtype* p = reinterpret_cast< tpbind_tcv_t::realtype* >(smartptr.getPointer());
		if (p) {
			const tpbind_tcv_t::traittype& t = *reinterpret_cast< const tpbind_tcv_t::traittype* >(&desc->traits.d);
			printf("a->set_param_default: spec\n");
			QList< TPointD > pt;
			for (int i = 0; i < t.cps; i ++) {
				pt.push_back(TPointD(t.array[i].x, t.array[i].y));
			}
			p->setDefaultValue(pt);
			p->setIsLinear(!(t.intep));
			}*/
		return true;
	}
};
 
/* primitive: TDoubleParam */
template <>
struct set_param_default_t<tpbind_dbl_t, std::false_type> {
	static bool set_param_default(Param *param, const toonz_param_desc_t *desc)
	{
		auto smartptr = param->param();
		tpbind_dbl_t::realtype *p = reinterpret_cast<tpbind_dbl_t::realtype *>(smartptr.getPointer());
		if (p) {
			const tpbind_dbl_t::traittype &t = *reinterpret_cast<const tpbind_dbl_t::traittype *>(&desc->traits.d);
			printf("p(%p)->set_param_default: typeid:%s desc:%p (%p)\n", p, typeid(tpbind_dbl_t::traittype).name(), desc, &desc->traits.d);
			p->setDefaultValue(t.def);
		}
		return true;
	}
};
 
/* primitive: TNotAnimatableParam */
template <typename Bind>
struct set_param_default_t<Bind, std::false_type> {
	static bool set_param_default(Param *param, const toonz_param_desc_t *desc)
	{
		auto smartptr = param->param();
		typename Bind::realtype *p = reinterpret_cast<typename Bind::realtype *>(smartptr.getPointer());
		if (p) {
			const typename Bind::traittype &t = *reinterpret_cast<const typename Bind::traittype *>(&desc->traits.d);
			printf("p(%p)->set_param_default: typeid:%s desc:%p (%p)\n", p, typeid(typename Bind::traittype).name(), desc, &desc->traits.d);
			p->setDefaultValue(t.def);
			p->setValue(t.def, false);
		}
		return true;
	}
};
 
/* Default Enum */
template <>
struct set_param_default_t<tpbind_enm_t, std::false_type> {
	static bool set_param_default(Param *param, const toonz_param_desc_t *desc)
	{
		auto smartptr = param->param();
		tpbind_enm_t::realtype *p = reinterpret_cast<tpbind_enm_t::realtype *>(smartptr.getPointer());
		if (p) {
			const tpbind_enm_t::traittype &t = *reinterpret_cast<const tpbind_enm_t::traittype *>(&desc->traits.d);
			for (int i = 0; i < t.enums; i++) {
				p->addItem(i, t.array[i]);
			}
			p->setValue(t.def, false);
		}
		return true;
	}
};
 
template <typename Bind>
bool set_param_default(Param *param, const toonz_param_desc_t *desc)
{
	if (!is_type_of<typename Bind::traittype>(desc))
		return false;
	return set_param_default_t<Bind>::set_param_default(param, desc);
}
 
template <typename T>
inline T *param_factory_(const toonz_param_desc_t *desc)
{
	return new T;
}
 
template <>
inline TPointParam *param_factory_(const toonz_param_desc_t *desc)
{
	return new TPointParam(TPointD(), true /* instanciate from plugin */);
}
 
template <>
inline TSpectrumParam *param_factory_(const toonz_param_desc_t *desc)
{
	const toonz_param_traits_spectrum_t &t = desc->traits.g;
	if (t.points) {
		std::vector<TSpectrum::ColorKey> keys(t.points);
		for (int i = 0; i < t.points; i++) {
			keys[i].first = t.array[i].w;
			keys[i].second = toPixel32(TPixelD(t.array[i].c0, t.array[i].c1, t.array[i].c2, t.array[i].m));
		}
		return new TSpectrumParam(t.points, keys.data());
	} else {
		return new TSpectrumParam(); /* use default constructor: デフォルトでは [black:white] の単純なものが設定される */
	}
}
 
inline TParam *parameter_factory(const toonz_param_desc_t *desc)
{
	switch (desc->traits_tag) {
	case TOONZ_PARAM_TYPE_DOUBLE:
		return param_factory_<TDoubleParam>(desc);
	case TOONZ_PARAM_TYPE_RANGE:
		return param_factory_<TRangeParam>(desc);
	case TOONZ_PARAM_TYPE_PIXEL:
		return param_factory_<TPixelParam>(desc);
	case TOONZ_PARAM_TYPE_POINT:
		return param_factory_<TPointParam>(desc);
	case TOONZ_PARAM_TYPE_ENUM:
		return param_factory_<TIntEnumParam>(desc);
	case TOONZ_PARAM_TYPE_INT:
		return param_factory_<TIntParam>(desc);
	case TOONZ_PARAM_TYPE_BOOL:
		return param_factory_<TBoolParam>(desc);
	case TOONZ_PARAM_TYPE_SPECTRUM:
		return param_factory_<TSpectrumParam>(desc);
	case TOONZ_PARAM_TYPE_STRING:
		return param_factory_<TStringParam>(desc);
	case TOONZ_PARAM_TYPE_TONECURVE:
		return param_factory_<TToneCurveParam>(desc);
	default:
		break;
	}
	return NULL;
}
 
template <typename T>
inline int check_pollution_(const T &t)
{
	if (t.reserved_)
		return TOONZ_PARAM_ERROR_POLLUTED;
	return 0;
}
 
template <typename T>
inline int check_traits_sanity_(const toonz_param_desc_t *desc)
{
	const T &t = reinterpret_cast<const T &>(desc->traits.d);
	return check_pollution_<T>(t);
}
 
template <>
inline int check_traits_sanity_<toonz_param_traits_double_t>(const toonz_param_desc_t *desc)
{
	int err = 0;
	const toonz_param_traits_double_t &t = desc->traits.d;
	err |= check_pollution_(t);
	if (t.min > t.max)
		err |= TOONZ_PARAM_ERROR_MIN_MAX;
	return 0;
}
 
template <>
inline int check_traits_sanity_<toonz_param_traits_range_t>(const toonz_param_desc_t *desc)
{
	int err = 0;
	const toonz_param_traits_range_t &t = desc->traits.rd;
	err |= check_pollution_(t);
	if (t.minmax.a == 0 && t.minmax.b == 0)
		return err; /* range に興味がない場合の 0,0 を許す */
	if (t.minmax.a > t.minmax.b)
		err |= TOONZ_PARAM_ERROR_MIN_MAX;
	return err;
}
 
template <>
inline int check_traits_sanity_<toonz_param_traits_enum_t>(const toonz_param_desc_t *desc)
{
	int err = 0;
	const toonz_param_traits_enum_t &t = desc->traits.e;
	err |= check_pollution_(t);
	if (t.enums == 0)
		return err;
	if (t.enums < 0)
		err |= TOONZ_PARAM_ERROR_ARRAY_NUM;
	if (t.array == NULL)
		err |= TOONZ_PARAM_ERROR_ARRAY;
	return err;
}
 
template <>
inline int check_traits_sanity_<toonz_param_traits_spectrum_t>(const toonz_param_desc_t *desc)
{
	int err = 0;
	const toonz_param_traits_spectrum_t &t = desc->traits.g;
	err |= check_pollution_(t);
	if (t.points == 0)
		return err;
	if (t.points < 0)
		err |= TOONZ_PARAM_ERROR_ARRAY_NUM;
	if (t.array == NULL)
		err |= TOONZ_PARAM_ERROR_ARRAY;
	return err;
}
 
/*
template <> int check_traits_sanity_< toonz_param_traits_tonecurve_t >(const toonz_param_desc_t* desc)
{
	int err = 0;
	const toonz_param_traits_tonecurve_t& t = desc->traits.tcv;
	err |= check_pollution_(t);
	if (t.points == 0)
		return err;
	if (t.points < 0)
		err |= TOONZ_PARAM_ERROR_ARRAY_NUM;
	if (t.array == NULL) 
		err |= TOONZ_PARAM_ERROR_ARRAY;
	return err;
}
*/
 
inline int check_traits_sanity(const toonz_param_desc_t *desc)
{
	int err = 0;
	switch (desc->traits_tag) {
	case TOONZ_PARAM_TYPE_DOUBLE:
		err = check_traits_sanity_<toonz_param_traits_double_t>(desc);
		break;
	case TOONZ_PARAM_TYPE_RANGE:
		err = check_traits_sanity_<toonz_param_traits_range_t>(desc);
		break;
	case TOONZ_PARAM_TYPE_PIXEL:
		err = check_traits_sanity_<toonz_param_traits_color_t>(desc);
		break;
	case TOONZ_PARAM_TYPE_POINT:
		err = check_traits_sanity_<toonz_param_traits_point_t>(desc);
		break;
	case TOONZ_PARAM_TYPE_ENUM:
		err = check_traits_sanity_<toonz_param_traits_enum_t>(desc);
		break;
	case TOONZ_PARAM_TYPE_INT:
		err = check_traits_sanity_<toonz_param_traits_int_t>(desc);
		break;
	case TOONZ_PARAM_TYPE_BOOL:
		err = check_traits_sanity_<toonz_param_traits_bool_t>(desc);
		break;
	case TOONZ_PARAM_TYPE_SPECTRUM:
		err = check_traits_sanity_<toonz_param_traits_spectrum_t>(desc);
		break;
	case TOONZ_PARAM_TYPE_STRING:
		err = check_traits_sanity_<toonz_param_traits_string_t>(desc);
		break;
	case TOONZ_PARAM_TYPE_TONECURVE:
		err = check_traits_sanity_<toonz_param_traits_tonecurve_t>(desc);
		break;
	default:
		err = TOONZ_PARAM_ERROR_TRAITS;
		break;
	}
	return err;
}
 
template <typename T>
inline bool param_type_check_(TParam *p, const toonz_param_desc_t *desc, size_t &vsz)
{
	if (typename T::realtype *d = dynamic_cast<typename T::realtype *>(p)) {
		if (is_type_of<typename T::traittype>(desc)) {
			vsz = sizeof(typename T::traittype::iovaluetype);
			return true;
		}
	}
	return false;
}
 
inline bool parameter_type_check(TParam *p, const toonz_param_desc_t *desc, size_t &vsz)
{
	switch (desc->traits_tag) {
	case TOONZ_PARAM_TYPE_DOUBLE:
		return param_type_check_<tpbind_dbl_t>(p, desc, vsz);
	case TOONZ_PARAM_TYPE_RANGE:
		return param_type_check_<tpbind_rng_t>(p, desc, vsz);
	case TOONZ_PARAM_TYPE_PIXEL:
		return param_type_check_<tpbind_col_t>(p, desc, vsz);
	case TOONZ_PARAM_TYPE_POINT:
		return param_type_check_<tpbind_pnt_t>(p, desc, vsz);
	case TOONZ_PARAM_TYPE_ENUM:
		return param_type_check_<tpbind_enm_t>(p, desc, vsz);
	case TOONZ_PARAM_TYPE_INT:
		return param_type_check_<tpbind_int_t>(p, desc, vsz);
	case TOONZ_PARAM_TYPE_BOOL:
		return param_type_check_<tpbind_bool_t>(p, desc, vsz);
	case TOONZ_PARAM_TYPE_SPECTRUM:
		return param_type_check_<tpbind_spc_t>(p, desc, vsz);
	case TOONZ_PARAM_TYPE_STRING:
		return param_type_check_<tpbind_str_t>(p, desc, vsz);
	case TOONZ_PARAM_TYPE_TONECURVE:
		return param_type_check_<tpbind_tcv_t>(p, desc, vsz);
	default:
		break;
	}
	return false;
}
 
template <typename T>
inline bool param_read_value_(TParam *p, const toonz_param_desc_t *desc, void *ptr, double frame, size_t isize, size_t &osize)
{
	/* isize は iovaluetype の size でなく count になったのでサイズチェックは無効 */
	//if (isize == sizeof(typename T::traittype::iovaluetype)) {
	auto r = reinterpret_cast<typename T::realtype *>(p);
	auto v = r->getValue();
	*reinterpret_cast<typename T::traittype::iovaluetype *>(ptr) = v;
	osize = 1;
	return true;
	//}
	return false;
}
 
template <>
inline bool param_read_value_<tpbind_dbl_t>(TParam *p, const toonz_param_desc_t *desc, void *ptr, double frame, size_t isize, size_t &osize)
{
	//if (isize == sizeof(tpbind_dbl_t::traittype::iovaluetype)) {
	auto r = reinterpret_cast<tpbind_dbl_t::realtype *>(p);
	auto v = r->getValue(frame);
	*reinterpret_cast<tpbind_dbl_t::traittype::iovaluetype *>(ptr) = v;
	osize = 1;
	return true;
	//}
	return false;
}
 
template <>
inline bool param_read_value_<tpbind_str_t>(TParam *p, const toonz_param_desc_t *desc, void *ptr, double frame, size_t isize, size_t &osize)
{
	auto r = reinterpret_cast<tpbind_str_t::realtype *>(p);
	const std::string str = QString::fromStdWString(r->getValue()).toStdString();
	std::size_t len = str.length() + 1;
	/* get_type() の返す大きさも文字列長+1 を含んでいる */
	if (isize < len)
		len = isize; /* 要求サイズが実際の長さより短くても良いが切り詰める(ただし 1 以上であること) */
 
	if (len > 0) {
		auto dst = reinterpret_cast<char *>(ptr);
		strncpy(dst, str.c_str(), len - 1);
		dst[len - 1] = '\0';
		osize = len;
		return true;
	}
	return false;
}
 
template <>
inline bool param_read_value_<tpbind_rng_t>(TParam *p, const toonz_param_desc_t *desc, void *ptr, double frame, size_t isize, size_t &osize)
{
	//if (isize == sizeof(tpbind_rng_t::traittype::iovaluetype)) {
	auto r = reinterpret_cast<tpbind_rng_t::realtype *>(p);
	auto v = r->getValue(frame);
	auto dst = reinterpret_cast<tpbind_rng_t::traittype::iovaluetype *>(ptr);
	dst->a = v.first;
	dst->b = v.second;
	osize = 1;
	return true;
	//}
	return false;
}
 
template <>
inline bool param_read_value_<tpbind_col_t>(TParam *p, const toonz_param_desc_t *desc, void *ptr, double frame, size_t isize, size_t &osize)
{
	//if (isize == sizeof(tpbind_col_t::traittype::iovaluetype)) {
	auto r = reinterpret_cast<tpbind_col_t::realtype *>(p);
	/* getValueD() だと 16bit * 4 が返る */
	//auto v = r->getValueD(frame);
	auto v = r->getValue(frame);
	auto dst = reinterpret_cast<tpbind_col_t::traittype::iovaluetype *>(ptr);
	dst->c0 = v.r;
	dst->c1 = v.g;
	dst->c2 = v.b;
	dst->m = v.m;
	osize = 1;
	return true;
	//}
	return false;
}
 
template <>
inline bool param_read_value_<tpbind_pnt_t>(TParam *p, const toonz_param_desc_t *desc, void *ptr, double frame, size_t isize, size_t &osize)
{
	//if (isize == sizeof(tpbind_pnt_t::traittype::iovaluetype)) {
	auto r = reinterpret_cast<tpbind_pnt_t::realtype *>(p);
	auto v = r->getValue(frame);
	auto dst = reinterpret_cast<tpbind_pnt_t::traittype::iovaluetype *>(ptr);
	dst->x = v.x;
	dst->y = v.y;
	osize = 1;
	return true;
	//}
	return false;
}
 
template <>
inline bool param_read_value_<tpbind_spc_t>(TParam *p, const toonz_param_desc_t *desc, void *ptr, double frame, size_t isize, size_t &osize)
{
	//if (isize == sizeof(tpbind_spc_t::traittype::iovaluetype)) {
	auto r = reinterpret_cast<tpbind_spc_t::realtype *>(p);
	auto dst = reinterpret_cast<tpbind_spc_t::traittype::iovaluetype *>(ptr);
	/* getValue64() だと 1channle 16bit が返るがデフォルト型に合わせる */
	auto v = r->getValue(frame).getValue(dst->w);
	dst->c0 = v.r;
	dst->c1 = v.g;
	dst->c2 = v.b;
	dst->m = v.m;
	osize = 1;
	return true;
	//}
	return false;
}
 
template <>
inline bool param_read_value_<tpbind_tcv_t>(TParam *p, const toonz_param_desc_t *desc, void *ptr, double frame, size_t isize, size_t &osize)
{
	auto r = reinterpret_cast<tpbind_tcv_t::realtype *>(p);
	QList<TPointD> points = r->getValue(frame);
	size_t ps = points.size();
	/* コントロールポイントのリストしか戻って来ない！ */
	if (isize >= ps) {
		int channel = r->getCurrentChannel();
		int interp = !r->isLinear();
		int c = isize < points.size() ? isize : points.size();
		for (int i = 0; i < c; i++) {
			auto dst = reinterpret_cast<tpbind_tcv_t::traittype::iovaluetype *>(ptr);
			dst[i].x = points[i].x;
			dst[i].y = points[i].y;
			dst[i].channel = channel;
			dst[i].interp = interp;
		}
		osize = c;
		return true;
	}
	return false;
}
 
inline bool parameter_read_value(TParam *p, const toonz_param_desc_t *desc, void *ptr, double frame, size_t isize, size_t &osize)
{
	size_t sz = 0;
	if (!parameter_type_check(p, desc, sz)) { // typecheck
		return false;
	}
 
	switch (desc->traits_tag) {
	case TOONZ_PARAM_TYPE_DOUBLE:
		return param_read_value_<tpbind_dbl_t>(p, desc, ptr, frame, isize, osize);
	case TOONZ_PARAM_TYPE_RANGE:
		return param_read_value_<tpbind_rng_t>(p, desc, ptr, frame, isize, osize);
	case TOONZ_PARAM_TYPE_PIXEL:
		return param_read_value_<tpbind_col_t>(p, desc, ptr, frame, isize, osize);
	case TOONZ_PARAM_TYPE_POINT:
		return param_read_value_<tpbind_pnt_t>(p, desc, ptr, frame, isize, osize);
	case TOONZ_PARAM_TYPE_ENUM:
		return param_read_value_<tpbind_enm_t>(p, desc, ptr, frame, isize, osize);
	case TOONZ_PARAM_TYPE_INT:
		return param_read_value_<tpbind_int_t>(p, desc, ptr, frame, isize, osize);
	case TOONZ_PARAM_TYPE_BOOL:
		return param_read_value_<tpbind_bool_t>(p, desc, ptr, frame, isize, osize);
	case TOONZ_PARAM_TYPE_SPECTRUM:
		return param_read_value_<tpbind_spc_t>(p, desc, ptr, frame, isize, osize);
	case TOONZ_PARAM_TYPE_STRING:
		return param_read_value_<tpbind_str_t>(p, desc, ptr, frame, isize, osize);
	case TOONZ_PARAM_TYPE_TONECURVE:
		return param_read_value_<tpbind_tcv_t>(p, desc, ptr, frame, isize, osize);
	default:
		break;
	}
	return false;
}
 
#endif