/// @cond EO_CXX_EO_IMPL

inline void elm::label::slide_go() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_label_slide_go());
}

inline Evas_Coord elm::label::wrap_width_get() const
{
   Evas_Coord _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_label_wrap_width_get());
   return _tmp_ret;
}

inline void elm::label::wrap_width_set(Evas_Coord w_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_label_wrap_width_set(w_));
}

inline double elm::label::slide_speed_get() const
{
   double _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_label_slide_speed_get());
   return _tmp_ret;
}

inline void elm::label::slide_speed_set(double speed_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_label_slide_speed_set(speed_));
}

inline Elm_Label_Slide_Mode elm::label::slide_mode_get() const
{
   Elm_Label_Slide_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_label_slide_mode_get());
   return _tmp_ret;
}

inline void elm::label::slide_mode_set(Elm_Label_Slide_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_label_slide_mode_set(mode_));
}

inline double elm::label::slide_duration_get() const
{
   double _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_label_slide_duration_get());
   return _tmp_ret;
}

inline void elm::label::slide_duration_set(double duration_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_label_slide_duration_set(duration_));
}

inline Elm_Wrap_Type elm::label::line_wrap_get() const
{
   Elm_Wrap_Type _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_label_line_wrap_get());
   return _tmp_ret;
}

inline void elm::label::line_wrap_set(Elm_Wrap_Type wrap_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_label_line_wrap_set(wrap_));
}

inline bool elm::label::ellipsis_get() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_label_ellipsis_get());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::label::ellipsis_set(bool ellipsis_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_label_ellipsis_set(::efl::eolian::to_c(ellipsis_)));
}

inline void eo_cxx::elm::label::slide_go() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_label_slide_go());
}

inline Evas_Coord eo_cxx::elm::label::wrap_width_get() const
{
   Evas_Coord _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_label_wrap_width_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::label::wrap_width_set(Evas_Coord w_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_label_wrap_width_set(w_));
}

inline double eo_cxx::elm::label::slide_speed_get() const
{
   double _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_label_slide_speed_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::label::slide_speed_set(double speed_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_label_slide_speed_set(speed_));
}

inline Elm_Label_Slide_Mode eo_cxx::elm::label::slide_mode_get() const
{
   Elm_Label_Slide_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_label_slide_mode_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::label::slide_mode_set(Elm_Label_Slide_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_label_slide_mode_set(mode_));
}

inline double eo_cxx::elm::label::slide_duration_get() const
{
   double _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_label_slide_duration_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::label::slide_duration_set(double duration_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_label_slide_duration_set(duration_));
}

inline Elm_Wrap_Type eo_cxx::elm::label::line_wrap_get() const
{
   Elm_Wrap_Type _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_label_line_wrap_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::label::line_wrap_set(Elm_Wrap_Type wrap_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_label_line_wrap_set(wrap_));
}

inline bool eo_cxx::elm::label::ellipsis_get() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_label_ellipsis_get());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::label::ellipsis_set(bool ellipsis_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_label_ellipsis_set(::efl::eolian::to_c(ellipsis_)));
}

inline ::eo_cxx::elm::label::operator ::elm::label() const
{
   return *static_cast<::elm::label const*>(static_cast<void const*>(this));
}

inline ::eo_cxx::elm::label::operator ::elm::label&()
{
   return *static_cast<::elm::label*>(static_cast<void*>(this));
}

inline ::eo_cxx::elm::label::operator ::elm::label const&() const
{
   return *static_cast<::elm::label const*>(static_cast<void const*>(this));
}

template <typename T>
void elm_label_slide_go_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->slide_go();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
Evas_Coord elm_label_wrap_width_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->wrap_width_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Evas_Coord _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_label_wrap_width_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Coord w_)
{
   try
      {
         static_cast<T*>(self->this_)->wrap_width_set(w_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
double elm_label_slide_speed_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->slide_speed_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         double _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_label_slide_speed_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, double speed_)
{
   try
      {
         static_cast<T*>(self->this_)->slide_speed_set(speed_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
Elm_Label_Slide_Mode elm_label_slide_mode_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->slide_mode_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Label_Slide_Mode _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_label_slide_mode_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Label_Slide_Mode mode_)
{
   try
      {
         static_cast<T*>(self->this_)->slide_mode_set(mode_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
double elm_label_slide_duration_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->slide_duration_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         double _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_label_slide_duration_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, double duration_)
{
   try
      {
         static_cast<T*>(self->this_)->slide_duration_set(duration_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
Elm_Wrap_Type elm_label_line_wrap_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->line_wrap_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Wrap_Type _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_label_line_wrap_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Wrap_Type wrap_)
{
   try
      {
         static_cast<T*>(self->this_)->line_wrap_set(wrap_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_label_ellipsis_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->ellipsis_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_Bool _tmp_ret{};
         return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_label_ellipsis_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool ellipsis_)
{
   try
      {
         static_cast<T*>(self->this_)->ellipsis_set(::efl::eolian::to_cxx<bool>(ellipsis_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

namespace efl { namespace eo { namespace detail {

template<>
struct operations< ::elm::label >
{
   template <typename T>
   struct type
         : virtual operations< ::elm::layout >::template type<T>
   {
      virtual void slide_go()
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_label_slide_go());
      }

      virtual Evas_Coord wrap_width_get()
      {
         Evas_Coord _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_label_wrap_width_get());
            return _tmp_ret;
      }

      virtual void wrap_width_set(Evas_Coord w_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_label_wrap_width_set(w_));
      }

      virtual double slide_speed_get()
      {
         double _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_label_slide_speed_get());
            return _tmp_ret;
      }

      virtual void slide_speed_set(double speed_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_label_slide_speed_set(speed_));
      }

      virtual Elm_Label_Slide_Mode slide_mode_get()
      {
         Elm_Label_Slide_Mode _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_label_slide_mode_get());
            return _tmp_ret;
      }

      virtual void slide_mode_set(Elm_Label_Slide_Mode mode_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_label_slide_mode_set(mode_));
      }

      virtual double slide_duration_get()
      {
         double _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_label_slide_duration_get());
            return _tmp_ret;
      }

      virtual void slide_duration_set(double duration_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_label_slide_duration_set(duration_));
      }

      virtual Elm_Wrap_Type line_wrap_get()
      {
         Elm_Wrap_Type _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_label_line_wrap_get());
            return _tmp_ret;
      }

      virtual void line_wrap_set(Elm_Wrap_Type wrap_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_label_line_wrap_set(wrap_));
      }

      virtual bool ellipsis_get()
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_label_ellipsis_get());
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void ellipsis_set(bool ellipsis_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_label_ellipsis_set(::efl::eolian::to_c(ellipsis_)));
      }

   };
};


template<>
struct operation_description_class_size< ::elm::label >
{
   static constexpr int value = 
#if defined(LABEL_PROTECTED) && defined(LABEL_BETA)
      13
#elif defined(LABEL_PROTECTED)
      13
#elif defined(LABEL_BETA)
      13
#else
      13
#endif
      + operation_description_class_size<::elm::layout >::value;
};

template <typename T>
int initialize_operation_description(::efl::eo::detail::tag<::elm::label>
                                 , Eo_Op_Description* ops)
{
   int i = 0;
   (void)i;
   (void)ops;
   ops[i].func = reinterpret_cast<void*>(& ::elm_label_slide_go_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_label_slide_go);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_label_wrap_width_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_label_wrap_width_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_label_wrap_width_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_label_wrap_width_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_label_slide_speed_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_label_slide_speed_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_label_slide_speed_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_label_slide_speed_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_label_slide_mode_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_label_slide_mode_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_label_slide_mode_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_label_slide_mode_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_label_slide_duration_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_label_slide_duration_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_label_slide_duration_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_label_slide_duration_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_label_line_wrap_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_label_line_wrap_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_label_line_wrap_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_label_line_wrap_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_label_ellipsis_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_label_ellipsis_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_label_ellipsis_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_label_ellipsis_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   initialize_operation_description<T>(::efl::eo::detail::tag<::elm::layout>(), &ops[operation_description_class_size< ::elm::label >::value]);
   return 0;
}
inline Eo_Class const* get_eo_class(tag<::elm::label>)
{
   return (ELM_LABEL_CLASS);
}

} } }

/// @endcond

