/// @cond EO_CXX_EO_IMPL

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline bool elm_interface_atspi_text::selection_add(int start_offset_, int end_offset_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_selection_add(start_offset_, end_offset_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline bool elm_interface_atspi_text::selection_remove(int selection_number_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_selection_remove(selection_number_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline Eina_Unicode elm_interface_atspi_text::character_get(int offset_) const
{
   Eina_Unicode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_character_get(offset_));
   return _tmp_ret;
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline char * elm_interface_atspi_text::string_get(Elm_Atspi_Text_Granularity granularity_, int * start_offset_, int * end_offset_) const
{
   char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_string_get(granularity_, start_offset_, end_offset_));
   return _tmp_ret;
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline char * elm_interface_atspi_text::text_get(int start_offset_, int end_offset_) const
{
   char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_get(start_offset_, end_offset_));
   return _tmp_ret;
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline int elm_interface_atspi_text::caret_offset_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_caret_offset_get());
   return _tmp_ret;
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline bool elm_interface_atspi_text::caret_offset_set(int offset_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_caret_offset_set(offset_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline bool elm_interface_atspi_text::attribute_get(::efl::eina::string_view name_, int * start_offset_, int * end_offset_, char ** value_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_attribute_get(::efl::eolian::to_c(name_), start_offset_, end_offset_, value_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline ::efl::eina::list< Elm_Atspi_Text_Attribute * > elm_interface_atspi_text::attributes_get(int * start_offset_, int * end_offset_) const
{
   Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_attributes_get(start_offset_, end_offset_));
   return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Atspi_Text_Attribute * >>(_tmp_ret, std::tuple<std::true_type, std::true_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline ::efl::eina::list< Elm_Atspi_Text_Attribute * > elm_interface_atspi_text::default_attributes_get() const
{
   Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_default_attributes_get());
   return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Atspi_Text_Attribute * >>(_tmp_ret, std::tuple<std::true_type, std::true_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline bool elm_interface_atspi_text::character_extents_get(int offset_, bool screen_coords_, Eina_Rectangle* rect_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_character_extents_get(offset_, ::efl::eolian::to_c(screen_coords_), rect_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline int elm_interface_atspi_text::character_count_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_character_count_get());
   return _tmp_ret;
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline int elm_interface_atspi_text::offset_at_point_get(bool screen_coords_, int x_, int y_) const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_offset_at_point_get(::efl::eolian::to_c(screen_coords_), x_, y_));
   return _tmp_ret;
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline ::efl::eina::list< Elm_Atspi_Text_Range * > elm_interface_atspi_text::bounded_ranges_get(bool screen_coords_, Eina_Rectangle rect_, Elm_Atspi_Text_Clip_Type xclip_, Elm_Atspi_Text_Clip_Type yclip_) const
{
   Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_bounded_ranges_get(::efl::eolian::to_c(screen_coords_), rect_, xclip_, yclip_));
   return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Atspi_Text_Range * >>(_tmp_ret, std::tuple<std::true_type, std::true_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline bool elm_interface_atspi_text::range_extents_get(bool screen_coords_, int start_offset_, int end_offset_, Eina_Rectangle* rect_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_range_extents_get(::efl::eolian::to_c(screen_coords_), start_offset_, end_offset_, rect_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline int elm_interface_atspi_text::selections_count_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_selections_count_get());
   return _tmp_ret;
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline void elm_interface_atspi_text::selection_get(int selection_number_, int* start_offset_, int* end_offset_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_interface_atspi_text_selection_get(selection_number_, start_offset_, end_offset_));
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline bool elm_interface_atspi_text::selection_set(int selection_number_, int start_offset_, int end_offset_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_selection_set(selection_number_, start_offset_, end_offset_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline bool eo_cxx::elm_interface_atspi_text::selection_add(int start_offset_, int end_offset_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_selection_add(start_offset_, end_offset_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline bool eo_cxx::elm_interface_atspi_text::selection_remove(int selection_number_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_selection_remove(selection_number_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline Eina_Unicode eo_cxx::elm_interface_atspi_text::character_get(int offset_) const
{
   Eina_Unicode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_character_get(offset_));
   return _tmp_ret;
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline char * eo_cxx::elm_interface_atspi_text::string_get(Elm_Atspi_Text_Granularity granularity_, int * start_offset_, int * end_offset_) const
{
   char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_string_get(granularity_, start_offset_, end_offset_));
   return _tmp_ret;
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline char * eo_cxx::elm_interface_atspi_text::text_get(int start_offset_, int end_offset_) const
{
   char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_get(start_offset_, end_offset_));
   return _tmp_ret;
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline int eo_cxx::elm_interface_atspi_text::caret_offset_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_caret_offset_get());
   return _tmp_ret;
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline bool eo_cxx::elm_interface_atspi_text::caret_offset_set(int offset_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_caret_offset_set(offset_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline bool eo_cxx::elm_interface_atspi_text::attribute_get(::efl::eina::string_view name_, int * start_offset_, int * end_offset_, char ** value_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_attribute_get(::efl::eolian::to_c(name_), start_offset_, end_offset_, value_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline ::efl::eina::list< Elm_Atspi_Text_Attribute * > eo_cxx::elm_interface_atspi_text::attributes_get(int * start_offset_, int * end_offset_) const
{
   Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_attributes_get(start_offset_, end_offset_));
   return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Atspi_Text_Attribute * >>(_tmp_ret, std::tuple<std::true_type, std::true_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline ::efl::eina::list< Elm_Atspi_Text_Attribute * > eo_cxx::elm_interface_atspi_text::default_attributes_get() const
{
   Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_default_attributes_get());
   return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Atspi_Text_Attribute * >>(_tmp_ret, std::tuple<std::true_type, std::true_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline bool eo_cxx::elm_interface_atspi_text::character_extents_get(int offset_, bool screen_coords_, Eina_Rectangle* rect_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_character_extents_get(offset_, ::efl::eolian::to_c(screen_coords_), rect_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline int eo_cxx::elm_interface_atspi_text::character_count_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_character_count_get());
   return _tmp_ret;
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline int eo_cxx::elm_interface_atspi_text::offset_at_point_get(bool screen_coords_, int x_, int y_) const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_offset_at_point_get(::efl::eolian::to_c(screen_coords_), x_, y_));
   return _tmp_ret;
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline ::efl::eina::list< Elm_Atspi_Text_Range * > eo_cxx::elm_interface_atspi_text::bounded_ranges_get(bool screen_coords_, Eina_Rectangle rect_, Elm_Atspi_Text_Clip_Type xclip_, Elm_Atspi_Text_Clip_Type yclip_) const
{
   Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_bounded_ranges_get(::efl::eolian::to_c(screen_coords_), rect_, xclip_, yclip_));
   return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Atspi_Text_Range * >>(_tmp_ret, std::tuple<std::true_type, std::true_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline bool eo_cxx::elm_interface_atspi_text::range_extents_get(bool screen_coords_, int start_offset_, int end_offset_, Eina_Rectangle* rect_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_range_extents_get(::efl::eolian::to_c(screen_coords_), start_offset_, end_offset_, rect_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline int eo_cxx::elm_interface_atspi_text::selections_count_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_selections_count_get());
   return _tmp_ret;
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline void eo_cxx::elm_interface_atspi_text::selection_get(int selection_number_, int* start_offset_, int* end_offset_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_interface_atspi_text_selection_get(selection_number_, start_offset_, end_offset_));
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
inline bool eo_cxx::elm_interface_atspi_text::selection_set(int selection_number_, int start_offset_, int end_offset_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_interface_atspi_text_selection_set(selection_number_, start_offset_, end_offset_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

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

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

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

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
bool _elm_interface_atspi_text_selection_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int start_offset_, int end_offset_)
{
   try
      {
         return static_cast<T*>(self->this_)->selection_add(start_offset_, end_offset_);
      }
   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>());
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
bool _elm_interface_atspi_text_selection_remove_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int selection_number_)
{
   try
      {
         return static_cast<T*>(self->this_)->selection_remove(selection_number_);
      }
   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>());
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
Eina_Unicode _elm_interface_atspi_text_character_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int offset_)
{
   try
      {
         return static_cast<T*>(self->this_)->character_get(offset_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_Unicode _tmp_ret{};
         return _tmp_ret;
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
char * _elm_interface_atspi_text_string_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Atspi_Text_Granularity granularity_, int * start_offset_, int * end_offset_)
{
   try
      {
         return static_cast<T*>(self->this_)->string_get(granularity_, start_offset_, end_offset_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         char * _tmp_ret{};
         return _tmp_ret;
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
char * _elm_interface_atspi_text_text_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int start_offset_, int end_offset_)
{
   try
      {
         return static_cast<T*>(self->this_)->text_get(start_offset_, end_offset_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         char * _tmp_ret{};
         return _tmp_ret;
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
int _elm_interface_atspi_text_caret_offset_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->caret_offset_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         int _tmp_ret{};
         return _tmp_ret;
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
bool _elm_interface_atspi_text_caret_offset_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int offset_)
{
   try
      {
         return static_cast<T*>(self->this_)->caret_offset_set(offset_);
      }
   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>());
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
bool _elm_interface_atspi_text_attribute_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * name_, int * start_offset_, int * end_offset_, char ** value_)
{
   try
      {
         return static_cast<T*>(self->this_)->attribute_get(::efl::eolian::to_cxx<::efl::eina::string_view>(name_, std::tuple<std::false_type>()), start_offset_, end_offset_, value_);
      }
   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>());
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
::efl::eina::list< Elm_Atspi_Text_Attribute * > _elm_interface_atspi_text_attributes_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int * start_offset_, int * end_offset_)
{
   try
      {
         return static_cast<T*>(self->this_)->attributes_get(start_offset_, end_offset_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_List * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Atspi_Text_Attribute * >>(_tmp_ret, std::tuple<std::true_type, std::true_type>());
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
::efl::eina::list< Elm_Atspi_Text_Attribute * > _elm_interface_atspi_text_default_attributes_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->default_attributes_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_List * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Atspi_Text_Attribute * >>(_tmp_ret, std::tuple<std::true_type, std::true_type>());
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
bool _elm_interface_atspi_text_character_extents_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int offset_, Eina_Bool screen_coords_, Eina_Rectangle* rect_)
{
   try
      {
         return static_cast<T*>(self->this_)->character_extents_get(offset_, ::efl::eolian::to_cxx<bool>(screen_coords_, std::tuple<std::false_type>()), rect_);
      }
   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>());
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
int _elm_interface_atspi_text_character_count_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->character_count_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         int _tmp_ret{};
         return _tmp_ret;
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
int _elm_interface_atspi_text_offset_at_point_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool screen_coords_, int x_, int y_)
{
   try
      {
         return static_cast<T*>(self->this_)->offset_at_point_get(::efl::eolian::to_cxx<bool>(screen_coords_, std::tuple<std::false_type>()), x_, y_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         int _tmp_ret{};
         return _tmp_ret;
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
::efl::eina::list< Elm_Atspi_Text_Range * > _elm_interface_atspi_text_bounded_ranges_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool screen_coords_, Eina_Rectangle rect_, Elm_Atspi_Text_Clip_Type xclip_, Elm_Atspi_Text_Clip_Type yclip_)
{
   try
      {
         return static_cast<T*>(self->this_)->bounded_ranges_get(::efl::eolian::to_cxx<bool>(screen_coords_, std::tuple<std::false_type>()), rect_, xclip_, yclip_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_List * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Atspi_Text_Range * >>(_tmp_ret, std::tuple<std::true_type, std::true_type>());
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
bool _elm_interface_atspi_text_range_extents_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool screen_coords_, int start_offset_, int end_offset_, Eina_Rectangle* rect_)
{
   try
      {
         return static_cast<T*>(self->this_)->range_extents_get(::efl::eolian::to_cxx<bool>(screen_coords_, std::tuple<std::false_type>()), start_offset_, end_offset_, rect_);
      }
   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>());
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
int _elm_interface_atspi_text_selections_count_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->selections_count_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         int _tmp_ret{};
         return _tmp_ret;
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
void _elm_interface_atspi_text_selection_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int selection_number_, int* start_offset_, int* end_offset_)
{
   try
      {
         static_cast<T*>(self->this_)->selection_get(selection_number_, start_offset_, end_offset_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
template <typename T>
bool _elm_interface_atspi_text_selection_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int selection_number_, int start_offset_, int end_offset_)
{
   try
      {
         return static_cast<T*>(self->this_)->selection_set(selection_number_, start_offset_, end_offset_);
      }
   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>());
      }
}
#endif

namespace efl { namespace eo { namespace detail {

template<>
struct operations< ::elm_interface_atspi_text >
{
   template <typename T>
   struct type
   {
#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual bool selection_add(int start_offset_, int end_offset_)
      {
         Eina_Bool _tmp_ret = {};

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

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual bool selection_remove(int selection_number_)
      {
         Eina_Bool _tmp_ret = {};

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

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual Eina_Unicode character_get(int offset_)
      {
         Eina_Unicode _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_interface_atspi_text_character_get(offset_));
            return _tmp_ret;
      }
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual char * string_get(Elm_Atspi_Text_Granularity granularity_, int * start_offset_, int * end_offset_)
      {
         char * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_interface_atspi_text_string_get(granularity_, start_offset_, end_offset_));
            return _tmp_ret;
      }
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual char * text_get(int start_offset_, int end_offset_)
      {
         char * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_interface_atspi_text_get(start_offset_, end_offset_));
            return _tmp_ret;
      }
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual int caret_offset_get()
      {
         int _tmp_ret = {};

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

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual bool caret_offset_set(int offset_)
      {
         Eina_Bool _tmp_ret = {};

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

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual bool attribute_get(::efl::eina::string_view name_, int * start_offset_, int * end_offset_, char ** value_)
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_interface_atspi_text_attribute_get(::efl::eolian::to_c(name_), start_offset_, end_offset_, value_));
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual ::efl::eina::list< Elm_Atspi_Text_Attribute * > attributes_get(int * start_offset_, int * end_offset_)
      {
         Eina_List * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_interface_atspi_text_attributes_get(start_offset_, end_offset_));
            return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Atspi_Text_Attribute * >>(_tmp_ret, std::tuple<std::true_type, std::true_type>());
      }
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual ::efl::eina::list< Elm_Atspi_Text_Attribute * > default_attributes_get()
      {
         Eina_List * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_interface_atspi_text_default_attributes_get());
            return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Atspi_Text_Attribute * >>(_tmp_ret, std::tuple<std::true_type, std::true_type>());
      }
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual bool character_extents_get(int offset_, bool screen_coords_, Eina_Rectangle* rect_)
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_interface_atspi_text_character_extents_get(offset_, ::efl::eolian::to_c(screen_coords_), rect_));
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual int character_count_get()
      {
         int _tmp_ret = {};

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

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual int offset_at_point_get(bool screen_coords_, int x_, int y_)
      {
         int _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_interface_atspi_text_offset_at_point_get(::efl::eolian::to_c(screen_coords_), x_, y_));
            return _tmp_ret;
      }
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual ::efl::eina::list< Elm_Atspi_Text_Range * > bounded_ranges_get(bool screen_coords_, Eina_Rectangle rect_, Elm_Atspi_Text_Clip_Type xclip_, Elm_Atspi_Text_Clip_Type yclip_)
      {
         Eina_List * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_interface_atspi_text_bounded_ranges_get(::efl::eolian::to_c(screen_coords_), rect_, xclip_, yclip_));
            return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Atspi_Text_Range * >>(_tmp_ret, std::tuple<std::true_type, std::true_type>());
      }
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual bool range_extents_get(bool screen_coords_, int start_offset_, int end_offset_, Eina_Rectangle* rect_)
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_interface_atspi_text_range_extents_get(::efl::eolian::to_c(screen_coords_), start_offset_, end_offset_, rect_));
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual int selections_count_get()
      {
         int _tmp_ret = {};

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

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual void selection_get(int selection_number_, int* start_offset_, int* end_offset_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_interface_atspi_text_selection_get(selection_number_, start_offset_, end_offset_));
      }
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
      virtual bool selection_set(int selection_number_, int start_offset_, int end_offset_)
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_interface_atspi_text_selection_set(selection_number_, start_offset_, end_offset_));
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
#endif

   };
};


template<>
struct operation_description_class_size< ::elm_interface_atspi_text >
{
   static constexpr int value = 
#if defined(ELM_INTERFACE_ATSPI_TEXT_PROTECTED) && defined(ELM_INTERFACE_ATSPI_TEXT_BETA)
      18
#elif defined(ELM_INTERFACE_ATSPI_TEXT_PROTECTED)
      18
#elif defined(ELM_INTERFACE_ATSPI_TEXT_BETA)
      0
#else
      0
#endif
;
};

template <typename T>
int initialize_operation_description(::efl::eo::detail::tag<::elm_interface_atspi_text>
                                 , Eo_Op_Description* ops)
{
   int i = 0;
   (void)i;
   (void)ops;
#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_selection_add_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_selection_add);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_selection_remove_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_selection_remove);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_character_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_character_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_string_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_string_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_text_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_caret_offset_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_caret_offset_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_caret_offset_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_caret_offset_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_attribute_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_attribute_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_attributes_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_attributes_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_default_attributes_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_default_attributes_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_character_extents_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_character_extents_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_character_count_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_character_count_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_offset_at_point_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_offset_at_point_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_bounded_ranges_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_bounded_ranges_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_range_extents_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_range_extents_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_selections_count_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_selections_count_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_selection_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_selection_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef ELM_INTERFACE_ATSPI_TEXT_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::_elm_interface_atspi_text_selection_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_interface_atspi_text_selection_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

   return 0;
}
inline Eo_Class const* get_eo_class(tag<::elm_interface_atspi_text>)
{
   return (ELM_INTERFACE_ATSPI_TEXT_INTERFACE);
}

} } }

/// @endcond

