#pragma once

#if !defined(TOONZ_PLUGIN_PARAM_TRAITS_H__)

#define TOONZ_PLUGIN_PARAM_TRAITS_H__

#include <toonz_params.h></toonz_params.h>

#include <functional></functional>

template <typename first,="" second="" typename=""></typename>

struct param_bind_t {

  typedef First traittype;

  typedef Second realtype;

  typedef typename std::is_compound<typename first::valuetype="">::value_type</typename>

      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;</toonz_param_traits_double_t,>

typedef param_bind_t<toonz_param_traits_range_t, trangeparam=""> tpbind_rng_t;</toonz_param_traits_range_t,>

typedef param_bind_t<toonz_param_traits_color_t, tpixelparam=""> tpbind_col_t;</toonz_param_traits_color_t,>

typedef param_bind_t<toonz_param_traits_point_t, tpointparam=""> tpbind_pnt_t;</toonz_param_traits_point_t,>

typedef param_bind_t<toonz_param_traits_enum_t, tintenumparam=""> tpbind_enm_t;</toonz_param_traits_enum_t,>

typedef param_bind_t<toonz_param_traits_int_t, tintparam=""> tpbind_int_t;</toonz_param_traits_int_t,>

typedef param_bind_t<toonz_param_traits_bool_t, tboolparam=""> tpbind_bool_t;</toonz_param_traits_bool_t,>

typedef param_bind_t<toonz_param_traits_spectrum_t, tspectrumparam=""></toonz_param_traits_spectrum_t,>

    tpbind_spc_t;

typedef param_bind_t<toonz_param_traits_string_t, tstringparam=""> tpbind_str_t;</toonz_param_traits_string_t,>

typedef param_bind_t<toonz_param_traits_tonecurve_t, ttonecurveparam=""></toonz_param_traits_tonecurve_t,>

    tpbind_tcv_t;

template <typename t=""></typename>

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 f="TDoubleParamP" rt,="" typename=""></typename>

inline F &get_func_a(RT *t) {

  assert(false);

}

template <typename f="TDoubleParamP" rt,="" typename=""></typename>

inline F &get_func_b(RT *t) {

  assert(false);

}

/* TRangeParam */

template <>

inline TDoubleParamP &get_func_a<trangeparam, tdoubleparamp="">(TRangeParam *t) {</trangeparam,>

  printf("get_func_a< TRangeParam, TDoubleParamP& >(TRangeParam* t)\n");

  return std::mem_fn(&TRangeParam::getMin)(t);

}

template <>

inline TDoubleParamP &get_func_b<trangeparam, tdoubleparamp="">(TRangeParam *t)</trangeparam,>

// 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_fn(&TRangeParam::getMax)(t);

}

/* TPointParam */

template <>

inline TDoubleParamP &get_func_a<tpointparam, tdoubleparamp="">(TPointParam *t)</tpointparam,>

// 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_fn(&TPointParam::getX)(t);

}

template <>

inline TDoubleParamP &get_func_b<tpointparam, tdoubleparamp="">(TPointParam *t)</tpointparam,>

// 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_fn(&TPointParam::getY)(t);

}

/* valuetype が集約型の場合、 スカラを取得するための関数 */

template <typename t,="" typename="" v=""></typename>

inline V get_1st_value(const T &) {}

template <typename t,="" typename="" v=""></typename>

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 Comp =

              typename std::is_compound<typename bind::valuetype="">::type,</typename>

          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=""></typename>

struct set_param_range_t<bind, 1="" std::true_type,=""> {</bind,>

  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());</typename>

    if (p) {

      const typename Bind::traittype &t =

          *reinterpret_cast<const *="" bind::traittype="" typename="">(&desc->traits.d);</const>

      auto subtype_a = get_func_a<typename bind::realtype="">(p);</typename>

      auto subtype_b = get_func_b<typename bind::realtype="">(p);</typename>

      auto a_minval  = get_1st_value<typename bind::valuetype,="" double="">(t.min);</typename>

      auto a_maxval  = get_2nd_value<typename bind::valuetype,="" double="">(t.min);</typename>

      auto b_minval  = get_1st_value<typename bind::valuetype,="" double="">(t.max);</typename>

      auto b_maxval  = get_2nd_value<typename bind::valuetype,="" double="">(t.max);</typename>

      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, 1="" std::true_type,=""> {</tpbind_rng_t,>

  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());</tpbind_rng_t::realtype>

    if (p) {

      const tpbind_rng_t::traittype &t = desc->traits.rd;

      auto subtype_a                   = get_func_a<tpbind_rng_t::realtype>(p);</tpbind_rng_t::realtype>

      auto subtype_b                   = get_func_b<tpbind_rng_t::realtype>(p);</tpbind_rng_t::realtype>

      auto a_minval = get_1st_value<tpbind_rng_t::valuetype, double="">(t.minmax);</tpbind_rng_t::valuetype,>

      auto a_maxval = get_2nd_value<tpbind_rng_t::valuetype, double="">(t.minmax);</tpbind_rng_t::valuetype,>

      (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=""></typename>

struct set_param_range_t<bind, 1="" std::false_type,=""> {</bind,>

  static bool set_param_range(Param *param, const toonz_param_desc_t *desc) {

    if (!is_type_of<typename bind::traittype="">(desc)) return false;</typename>

    auto smartptr = param->param();

    typename Bind::realtype *p =

        reinterpret_cast<typename *="" bind::realtype="">(smartptr.getPointer());</typename>

    if (p) {

      const typename Bind::traittype &t =

          *reinterpret_cast<const *="" bind::traittype="" typename="">(&desc->traits.d);</const>

      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=""></typename>

bool set_param_range(Param *param, const toonz_param_desc_t *desc) {

  if (!is_type_of<typename bind::traittype="">(desc)) return false;</typename>

  return set_param_range_t<bind>::set_param_range(param, desc);</bind>

}

template 

          typename Comp =

              typename std::is_compound<typename bind::valuetype="">::type></typename>

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=""></typename>

struct set_param_default_t<bind, std::true_type=""> {</bind,>

  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());</typename>

    if (p) {

      const typename Bind::traittype &t =

          *reinterpret_cast<const *="" bind::traittype="" typename="">(&desc->traits.d);</const>

      auto subtype_a = get_func_a<typename bind::realtype="">(p);</typename>

      auto subtype_b = get_func_b<typename bind::realtype="">(p);</typename>

      auto a_defval  = get_1st_value<typename bind::valuetype,="" double="">(t.def);</typename>

      auto b_defval  = get_2nd_value<typename bind::valuetype,="" double="">(t.def);</typename>

      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=""> {</tpbind_col_t,>

  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());</tpbind_col_t::realtype>

    if (p) {

      const tpbind_col_t::traittype &t =

          *reinterpret_cast<const *="" tpbind_col_t::traittype="">(&desc->traits.d);</const>

      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=""> {</tpbind_str_t,>

  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());</tpbind_str_t::realtype>

    if (p) {

      const tpbind_str_t::traittype &t =

          *reinterpret_cast<const *="" tpbind_str_t::traittype="">(&desc->traits.d);</const>

      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=""> {</tpbind_spc_t,>

  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=""> {</tpbind_tcv_t,>

  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=""> {</tpbind_dbl_t,>

  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());</tpbind_dbl_t::realtype>

    if (p) {

      const tpbind_dbl_t::traittype &t =

          *reinterpret_cast<const *="" tpbind_dbl_t::traittype="">(&desc->traits.d);</const>

      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=""></typename>

struct set_param_default_t<bind, std::false_type=""> {</bind,>

  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());</typename>

    if (p) {

      const typename Bind::traittype &t =

          *reinterpret_cast<const *="" bind::traittype="" typename="">(&desc->traits.d);</const>

      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=""> {</tpbind_enm_t,>

  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());</tpbind_enm_t::realtype>

    if (p) {

      const tpbind_enm_t::traittype &t =

          *reinterpret_cast<const *="" tpbind_enm_t::traittype="">(&desc->traits.d);</const>

      for (int i = 0; i < t.enums; i++) {

        p->addItem(i, t.array[i]);

      }

      p->setValue(t.def, false);

    }

    return true;

  }

};

template <typename bind=""></typename>

bool set_param_default(Param *param, const toonz_param_desc_t *desc) {

  if (!is_type_of<typename bind::traittype="">(desc)) return false;</typename>

  return set_param_default_t<bind>::set_param_default(param, desc);</bind>

}

template <typename t=""></typename>

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);</tspectrum::colorkey>

    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(keys);

  } 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);</tdoubleparam>

  case TOONZ_PARAM_TYPE_RANGE:

    return param_factory_<trangeparam>(desc);</trangeparam>

  case TOONZ_PARAM_TYPE_PIXEL:

    return param_factory_<tpixelparam>(desc);</tpixelparam>

  case TOONZ_PARAM_TYPE_POINT:

    return param_factory_<tpointparam>(desc);</tpointparam>

  case TOONZ_PARAM_TYPE_ENUM:

    return param_factory_<tintenumparam>(desc);</tintenumparam>

  case TOONZ_PARAM_TYPE_INT:

    return param_factory_<tintparam>(desc);</tintparam>

  case TOONZ_PARAM_TYPE_BOOL:

    return param_factory_<tboolparam>(desc);</tboolparam>

  case TOONZ_PARAM_TYPE_SPECTRUM:

    return param_factory_<tspectrumparam>(desc);</tspectrumparam>

  case TOONZ_PARAM_TYPE_STRING:

    return param_factory_<tstringparam>(desc);</tstringparam>

  case TOONZ_PARAM_TYPE_TONECURVE:

    return param_factory_<ttonecurveparam>(desc);</ttonecurveparam>

  default:

    break;

  }

  return NULL;

}

template <typename t=""></typename>

inline int check_pollution_(const T &t) {

  if (t.reserved_) return TOONZ_PARAM_ERROR_POLLUTED;

  return 0;

}

template <typename t=""></typename>

inline int check_traits_sanity_(const toonz_param_desc_t *desc) {

  const T &t = reinterpret_cast<const &="" t="">(desc->traits.d);</const>

  return check_pollution_<t>(t);</t>

}

template <>

inline int check_traits_sanity_<toonz_param_traits_double_t>(</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>(</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>(</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>(</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);</toonz_param_traits_double_t>

    break;

  case TOONZ_PARAM_TYPE_RANGE:

    err = check_traits_sanity_<toonz_param_traits_range_t>(desc);</toonz_param_traits_range_t>

    break;

  case TOONZ_PARAM_TYPE_PIXEL:

    err = check_traits_sanity_<toonz_param_traits_color_t>(desc);</toonz_param_traits_color_t>

    break;

  case TOONZ_PARAM_TYPE_POINT:

    err = check_traits_sanity_<toonz_param_traits_point_t>(desc);</toonz_param_traits_point_t>

    break;

  case TOONZ_PARAM_TYPE_ENUM:

    err = check_traits_sanity_<toonz_param_traits_enum_t>(desc);</toonz_param_traits_enum_t>

    break;

  case TOONZ_PARAM_TYPE_INT:

    err = check_traits_sanity_<toonz_param_traits_int_t>(desc);</toonz_param_traits_int_t>

    break;

  case TOONZ_PARAM_TYPE_BOOL:

    err = check_traits_sanity_<toonz_param_traits_bool_t>(desc);</toonz_param_traits_bool_t>

    break;

  case TOONZ_PARAM_TYPE_SPECTRUM:

    err = check_traits_sanity_<toonz_param_traits_spectrum_t>(desc);</toonz_param_traits_spectrum_t>

    break;

  case TOONZ_PARAM_TYPE_STRING:

    err = check_traits_sanity_<toonz_param_traits_string_t>(desc);</toonz_param_traits_string_t>

    break;

  case TOONZ_PARAM_TYPE_TONECURVE:

    err = check_traits_sanity_<toonz_param_traits_tonecurve_t>(desc);</toonz_param_traits_tonecurve_t>

    break;

  default:

    err = TOONZ_PARAM_ERROR_TRAITS;

    break;

  }

  return err;

}

template <typename t=""></typename>

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)) {</typename>

    if (is_type_of<typename t::traittype="">(desc)) {</typename>

      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);</tpbind_dbl_t>

  case TOONZ_PARAM_TYPE_RANGE:

    return param_type_check_<tpbind_rng_t>(p, desc, vsz);</tpbind_rng_t>

  case TOONZ_PARAM_TYPE_PIXEL:

    return param_type_check_<tpbind_col_t>(p, desc, vsz);</tpbind_col_t>

  case TOONZ_PARAM_TYPE_POINT:

    return param_type_check_<tpbind_pnt_t>(p, desc, vsz);</tpbind_pnt_t>

  case TOONZ_PARAM_TYPE_ENUM:

    return param_type_check_<tpbind_enm_t>(p, desc, vsz);</tpbind_enm_t>

  case TOONZ_PARAM_TYPE_INT:

    return param_type_check_<tpbind_int_t>(p, desc, vsz);</tpbind_int_t>

  case TOONZ_PARAM_TYPE_BOOL:

    return param_type_check_<tpbind_bool_t>(p, desc, vsz);</tpbind_bool_t>

  case TOONZ_PARAM_TYPE_SPECTRUM:

    return param_type_check_<tpbind_spc_t>(p, desc, vsz);</tpbind_spc_t>

  case TOONZ_PARAM_TYPE_STRING:

    return param_type_check_<tpbind_str_t>(p, desc, vsz);</tpbind_str_t>

  case TOONZ_PARAM_TYPE_TONECURVE:

    return param_type_check_<tpbind_tcv_t>(p, desc, vsz);</tpbind_tcv_t>

  default:

    break;

  }

  return false;

}

template <typename t=""></typename>

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);</typename>

  auto v = r->getValue();

  *reinterpret_cast<typename *="" t::traittype::iovaluetype="">(ptr) = v;</typename>

  osize                                                        = 1;

  return true;

  //}

  return false;

}

template <>

inline bool param_read_value_<tpbind_dbl_t>(TParam *p,</tpbind_dbl_t>

                                            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);</tpbind_dbl_t::realtype>

  auto v = r->getValue(frame);

  *reinterpret_cast<tpbind_dbl_t::traittype::iovaluetype *="">(ptr) = v;</tpbind_dbl_t::traittype::iovaluetype>

  osize                                                          = 1;

  return true;

  //}

  return false;

}

template <>

inline bool param_read_value_<tpbind_str_t>(TParam *p,</tpbind_str_t>

                                            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);</tpbind_str_t::realtype>

  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);</char>

    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,</tpbind_rng_t>

                                            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);</tpbind_rng_t::realtype>

  auto v   = r->getValue(frame);

  auto dst = reinterpret_cast<tpbind_rng_t::traittype::iovaluetype *="">(ptr);</tpbind_rng_t::traittype::iovaluetype>

  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,</tpbind_col_t>

                                            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);</tpbind_col_t::realtype>

  /* getValueD() だと 16bit * 4 が返る */

  // auto v = r->getValueD(frame);

  auto v   = r->getValue(frame);

  auto dst = reinterpret_cast<tpbind_col_t::traittype::iovaluetype *="">(ptr);</tpbind_col_t::traittype::iovaluetype>

  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,</tpbind_pnt_t>

                                            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);</tpbind_pnt_t::realtype>

  auto v   = r->getValue(frame);

  auto dst = reinterpret_cast<tpbind_pnt_t::traittype::iovaluetype *="">(ptr);</tpbind_pnt_t::traittype::iovaluetype>

  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,</tpbind_spc_t>

                                            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);</tpbind_spc_t::realtype>

  auto dst = reinterpret_cast<tpbind_spc_t::traittype::iovaluetype *="">(ptr);</tpbind_spc_t::traittype::iovaluetype>

  /* 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,</tpbind_tcv_t>

                                            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);</tpbind_tcv_t::realtype>

  QList<tpointd> points = r->getValue(frame);</tpointd>

  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);</tpbind_tcv_t::traittype::iovaluetype>

      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);</tpbind_dbl_t>

  case TOONZ_PARAM_TYPE_RANGE:

    return param_read_value_<tpbind_rng_t>(p, desc, ptr, frame, isize, osize);</tpbind_rng_t>

  case TOONZ_PARAM_TYPE_PIXEL:

    return param_read_value_<tpbind_col_t>(p, desc, ptr, frame, isize, osize);</tpbind_col_t>

  case TOONZ_PARAM_TYPE_POINT:

    return param_read_value_<tpbind_pnt_t>(p, desc, ptr, frame, isize, osize);</tpbind_pnt_t>

  case TOONZ_PARAM_TYPE_ENUM:

    return param_read_value_<tpbind_enm_t>(p, desc, ptr, frame, isize, osize);</tpbind_enm_t>

  case TOONZ_PARAM_TYPE_INT:

    return param_read_value_<tpbind_int_t>(p, desc, ptr, frame, isize, osize);</tpbind_int_t>

  case TOONZ_PARAM_TYPE_BOOL:

    return param_read_value_<tpbind_bool_t>(p, desc, ptr, frame, isize, osize);</tpbind_bool_t>

  case TOONZ_PARAM_TYPE_SPECTRUM:

    return param_read_value_<tpbind_spc_t>(p, desc, ptr, frame, isize, osize);</tpbind_spc_t>

  case TOONZ_PARAM_TYPE_STRING:

    return param_read_value_<tpbind_str_t>(p, desc, ptr, frame, isize, osize);</tpbind_str_t>

  case TOONZ_PARAM_TYPE_TONECURVE:

    return param_read_value_<tpbind_tcv_t>(p, desc, ptr, frame, isize, osize);</tpbind_tcv_t>

  default:

    break;

  }

  return false;

}

#endif