#ifndef EFL_GENERATED_EVAS_TEXT_HH
#define EFL_GENERATED_EVAS_TEXT_HH

#include <Eo.hh>

#include <eo_cxx_interop.hh>

extern "C"
{
#include "evas_text.eo.h"
}

#include "evas_object.eo.hh"
#include <string>

namespace evas { 

struct text
      : evas::object
{
   /// @brief Eo Constructor.
   ///
   /// Constructs the object from an Eo* pointer stealing its ownership.
   ///
   /// @param eo The Eo object pointer.
   ///
   explicit text(Eo* eo)
      : evas::object(eo)
   {}

   /// @brief nullptr_t Constructor.
   ///
   /// Constructs an empty (null) object.
   ///
   explicit text(std::nullptr_t)
      : evas::object(nullptr)
   {}

   text(efl::eo::parent_type _p = (efl::eo::parent = nullptr))
      : text(_c0(_p))
   {}

   /// @brief Copy Constructor.
   ///
   text(text const& other)
      : evas::object(eo_ref(other._eo_ptr()))
   {}

   ~text() {}

   /// @brief Returns the logical position of the last char in the text up to the pos given. this is NOT the position of the last char because of the possibility of RTL in the text.
   ///
   /// @param x in
   /// @param y in
   ///
   int last_up_to_pos(Evas_Coord x_, Evas_Coord y_) const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_last_up_to_pos(x_, y_));
      return _tmp_ret;
   }

   /// @param x in
   /// @param y in
   /// @param[out] cx out
   /// @param[out] cy out
   /// @param[out] cw out
   /// @param[out] ch out
   ///
   int char_coords_get(Evas_Coord x_, Evas_Coord y_, Evas_Coord* cx_, Evas_Coord* cy_, Evas_Coord* cw_, Evas_Coord* ch_) const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_char_coords_get(x_, y_, cx_, cy_, cw_, ch_));
      return _tmp_ret;
   }

   /// @brief Retrieve position and dimension information of a character within a text @c Evas_Object.
   ///
   /// This function is used to obtain the X, Y, width and height of the character
   /// located at @p pos within the @c Evas_Object @p obj. @p obj must be a text object
   /// as created with evas_object_text_add(). Any of the @c Evas_Coord parameters (@p cx,
   /// @p cy, @p cw, @p ch) may be @c NULL in which case no value will be assigned to that
   /// parameter.
   ///
   /// @return @c EINA_FALSE on success, @c EINA_TRUE on error.
   ///
   /// @param pos The character position to request co-ordinates for.
   /// @param[out] cx A pointer to an @c Evas_Coord to store the X value in (can be NULL).
   /// @param[out] cy A pointer to an @c Evas_Coord to store the Y value in (can be NULL).
   /// @param[out] cw A pointer to an @c Evas_Coord to store the Width value in (can be NULL).
   /// @param[out] ch A pointer to an @c Evas_Coord to store the Height value in (can be NULL).
   ///
   bool char_pos_get(int pos_, Evas_Coord* cx_, Evas_Coord* cy_, Evas_Coord* cw_, Evas_Coord* ch_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_char_pos_get(pos_, cx_, cy_, cw_, ch_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param font_source The font file's path.
   ///
   std::string font_source_get() const
   {
      const char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_font_source_get());
      return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param font_source The font file's path.
   ///
   void font_source_set(std::string font_source_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_font_source_set(efl::eolian::to_c(font_source_)));
   }

   /// @param r The red component of the given color.
   /// @param g The green component of the given color.
   /// @param b The blue component of the given color.
   /// @param a The alpha component of the given color.
   ///
   void shadow_color_get(int* r_, int* g_, int* b_, int* a_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_shadow_color_get(r_, g_, b_, a_));
   }

   /// @param r The red component of the given color.
   /// @param g The green component of the given color.
   /// @param b The blue component of the given color.
   /// @param a The alpha component of the given color.
   ///
   void shadow_color_set(int r_, int g_, int b_, int a_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_shadow_color_set(r_, g_, b_, a_));
   }

   /// @param ellipsis the ellipsis.
   ///
   double ellipsis_get() const
   {
      double _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_ellipsis_get());
      return _tmp_ret;
   }

   /// @param ellipsis the ellipsis.
   ///
   void ellipsis_set(double ellipsis_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_ellipsis_set(ellipsis_));
   }

   /// @param delim A null terminated string of delimiters, e.g ",|".
   ///
   std::string bidi_delimiters_get() const
   {
      const char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_bidi_delimiters_get());
      return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param delim A null terminated string of delimiters, e.g ",|".
   ///
   void bidi_delimiters_set(std::string delim_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_bidi_delimiters_set(efl::eolian::to_c(delim_)));
   }

   /// @param r The red component of the given color.
   /// @param g The green component of the given color.
   /// @param b The blue component of the given color.
   /// @param a The alpha component of the given color.
   ///
   void outline_color_get(int* r_, int* g_, int* b_, int* a_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_outline_color_get(r_, g_, b_, a_));
   }

   /// @param r The red component of the given color.
   /// @param g The green component of the given color.
   /// @param b The blue component of the given color.
   /// @param a The alpha component of the given color.
   ///
   void outline_color_set(int r_, int g_, int b_, int a_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_outline_color_set(r_, g_, b_, a_));
   }

   /// @param text Text string to display on it.
   ///
   std::string text_get() const
   {
      const char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_get());
      return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param text Text string to display on it.
   ///
   void text_set(std::string text_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_set(efl::eolian::to_c(text_)));
   }

   /// @param r The red component of the given color.
   /// @param g The green component of the given color.
   /// @param b The blue component of the given color.
   /// @param a The alpha component of the given color.
   ///
   void glow2_color_get(int* r_, int* g_, int* b_, int* a_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_glow2_color_get(r_, g_, b_, a_));
   }

   /// @param r The red component of the given color.
   /// @param g The green component of the given color.
   /// @param b The blue component of the given color.
   /// @param a The alpha component of the given color.
   ///
   void glow2_color_set(int r_, int g_, int b_, int a_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_glow2_color_set(r_, g_, b_, a_));
   }

   /// @param font The font family name or filename.
   /// @param size The font size, in points.
   ///
   void font_get(const char ** font_, Evas_Font_Size* size_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_font_get(font_, size_));
   }

   /// @param font The font family name or filename.
   /// @param size The font size, in points.
   ///
   void font_set(std::string font_, Evas_Font_Size size_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_font_set(efl::eolian::to_c(font_), size_));
   }

   /// @param style a style type.
   ///
   Evas_Text_Style_Type style_get() const
   {
      Evas_Text_Style_Type _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_style_get());
      return _tmp_ret;
   }

   /// @param style a style type.
   ///
   void style_set(Evas_Text_Style_Type style_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_style_set(style_));
   }

   /// @param r The red component of the given color.
   /// @param g The green component of the given color.
   /// @param b The blue component of the given color.
   /// @param a The alpha component of the given color.
   ///
   void glow_color_get(int* r_, int* g_, int* b_, int* a_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_glow_color_get(r_, g_, b_, a_));
   }

   /// @param r The red component of the given color.
   /// @param g The green component of the given color.
   /// @param b The blue component of the given color.
   /// @param a The alpha component of the given color.
   ///
   void glow_color_set(int r_, int g_, int b_, int a_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_glow_color_set(r_, g_, b_, a_));
   }

   /// @param program The program code, as defined
   /// by the @ref evasfiltersref "Evas filters script language".
   /// Pass NULL to remove the former program and switch back
   /// to the standard text effect
   ///
   void filter_program_set(std::string program_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_filter_program_set(efl::eolian::to_c(program_)));
   }

   /// @param name Object name as used in the program code
   /// @param eobj Eo object to use through proxy rendering
   ///
   void filter_source_set(std::string name_, Eo * eobj_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_filter_source_set(efl::eolian::to_c(name_), eobj_));
   }

   Evas_Coord max_descent_get() const
   {
      Evas_Coord _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_max_descent_get());
      return _tmp_ret;
   }

   /// @param l The left pad (or @c NULL).
   /// @param r The right pad (or @c NULL).
   /// @param t The top pad (or @c NULL).
   /// @param b The bottom pad (or @c NULL).
   ///
   void style_pad_get(int* l_, int* r_, int* t_, int* b_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_text_style_pad_get(l_, r_, t_, b_));
   }

   Evas_BiDi_Direction direction_get() const
   {
      Evas_BiDi_Direction _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_direction_get());
      return _tmp_ret;
   }

   Evas_Coord ascent_get() const
   {
      Evas_Coord _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_ascent_get());
      return _tmp_ret;
   }

   Evas_Coord horiz_advance_get() const
   {
      Evas_Coord _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_horiz_advance_get());
      return _tmp_ret;
   }

   Evas_Coord inset_get() const
   {
      Evas_Coord _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_inset_get());
      return _tmp_ret;
   }

   Evas_Coord max_ascent_get() const
   {
      Evas_Coord _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_max_ascent_get());
      return _tmp_ret;
   }

   Evas_Coord vert_advance_get() const
   {
      Evas_Coord _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_vert_advance_get());
      return _tmp_ret;
   }

   Evas_Coord descent_get() const
   {
      Evas_Coord _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_text_descent_get());
      return _tmp_ret;
   }

   static Eo_Class const* _eo_class()
   {
      return(EVAS_TEXT_CLASS);
   }

private:
   static Eo* _c0(efl::eo::parent_type _p)
   {
      return eo_add_custom(EVAS_TEXT_CLASS, _p._eo_raw, eo_constructor());
   }

};
} 

template <typename T>
int evas_text_last_up_to_pos_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord x_, Evas_Coord y_)
{
   return static_cast<T*>(self->this_)->last_up_to_pos(x_, y_);
}

template <typename T>
int evas_text_char_coords_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord x_, Evas_Coord y_, Evas_Coord* cx_, Evas_Coord* cy_, Evas_Coord* cw_, Evas_Coord* ch_)
{
   return static_cast<T*>(self->this_)->char_coords_get(x_, y_, cx_, cy_, cw_, ch_);
}

template <typename T>
bool evas_text_char_pos_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int pos_, Evas_Coord* cx_, Evas_Coord* cy_, Evas_Coord* cw_, Evas_Coord* ch_)
{
   return static_cast<T*>(self->this_)->char_pos_get(pos_, cx_, cy_, cw_, ch_);
}

template <typename T>
std::string evas_text_font_source_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->font_source_get();
}

template <typename T>
void evas_text_font_source_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * font_source_)
{
   static_cast<T*>(self->this_)->font_source_set(efl::eolian::to_cxx<std::string>(font_source_, std::tuple<std::false_type>()));
}

template <typename T>
void evas_text_shadow_color_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int* r_, int* g_, int* b_, int* a_)
{
   static_cast<T*>(self->this_)->shadow_color_get(r_, g_, b_, a_);
}

template <typename T>
void evas_text_shadow_color_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int r_, int g_, int b_, int a_)
{
   static_cast<T*>(self->this_)->shadow_color_set(r_, g_, b_, a_);
}

template <typename T>
double evas_text_ellipsis_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->ellipsis_get();
}

template <typename T>
void evas_text_ellipsis_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, double ellipsis_)
{
   static_cast<T*>(self->this_)->ellipsis_set(ellipsis_);
}

template <typename T>
std::string evas_text_bidi_delimiters_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->bidi_delimiters_get();
}

template <typename T>
void evas_text_bidi_delimiters_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * delim_)
{
   static_cast<T*>(self->this_)->bidi_delimiters_set(efl::eolian::to_cxx<std::string>(delim_, std::tuple<std::false_type>()));
}

template <typename T>
void evas_text_outline_color_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int* r_, int* g_, int* b_, int* a_)
{
   static_cast<T*>(self->this_)->outline_color_get(r_, g_, b_, a_);
}

template <typename T>
void evas_text_outline_color_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int r_, int g_, int b_, int a_)
{
   static_cast<T*>(self->this_)->outline_color_set(r_, g_, b_, a_);
}

template <typename T>
std::string evas_text_text_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->text_get();
}

template <typename T>
void evas_text_text_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * text_)
{
   static_cast<T*>(self->this_)->text_set(efl::eolian::to_cxx<std::string>(text_, std::tuple<std::false_type>()));
}

template <typename T>
void evas_text_glow2_color_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int* r_, int* g_, int* b_, int* a_)
{
   static_cast<T*>(self->this_)->glow2_color_get(r_, g_, b_, a_);
}

template <typename T>
void evas_text_glow2_color_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int r_, int g_, int b_, int a_)
{
   static_cast<T*>(self->this_)->glow2_color_set(r_, g_, b_, a_);
}

template <typename T>
void evas_text_font_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char ** font_, Evas_Font_Size* size_)
{
   static_cast<T*>(self->this_)->font_get(font_, size_);
}

template <typename T>
void evas_text_font_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * font_, Evas_Font_Size size_)
{
   static_cast<T*>(self->this_)->font_set(efl::eolian::to_cxx<std::string>(font_, std::tuple<std::false_type>()), size_);
}

template <typename T>
Evas_Text_Style_Type evas_text_style_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->style_get();
}

template <typename T>
void evas_text_style_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Text_Style_Type style_)
{
   static_cast<T*>(self->this_)->style_set(style_);
}

template <typename T>
void evas_text_glow_color_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int* r_, int* g_, int* b_, int* a_)
{
   static_cast<T*>(self->this_)->glow_color_get(r_, g_, b_, a_);
}

template <typename T>
void evas_text_glow_color_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int r_, int g_, int b_, int a_)
{
   static_cast<T*>(self->this_)->glow_color_set(r_, g_, b_, a_);
}

template <typename T>
void evas_text_filter_program_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * program_)
{
   static_cast<T*>(self->this_)->filter_program_set(efl::eolian::to_cxx<std::string>(program_, std::tuple<std::false_type>()));
}

template <typename T>
void evas_text_filter_source_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * name_, Eo * eobj_)
{
   static_cast<T*>(self->this_)->filter_source_set(efl::eolian::to_cxx<std::string>(name_, std::tuple<std::false_type>()), eobj_);
}

template <typename T>
Evas_Coord evas_text_max_descent_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->max_descent_get();
}

template <typename T>
void evas_text_style_pad_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, int* l_, int* r_, int* t_, int* b_)
{
   static_cast<T*>(self->this_)->style_pad_get(l_, r_, t_, b_);
}

template <typename T>
Evas_BiDi_Direction evas_text_direction_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->direction_get();
}

template <typename T>
Evas_Coord evas_text_ascent_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->ascent_get();
}

template <typename T>
Evas_Coord evas_text_horiz_advance_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->horiz_advance_get();
}

template <typename T>
Evas_Coord evas_text_inset_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->inset_get();
}

template <typename T>
Evas_Coord evas_text_max_ascent_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->max_ascent_get();
}

template <typename T>
Evas_Coord evas_text_vert_advance_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->vert_advance_get();
}

template <typename T>
Evas_Coord evas_text_descent_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->descent_get();
}

namespace efl { namespace eo { namespace detail {

template<>
struct operations< evas::text >
{
   template <typename T>
   struct type
   {
      virtual int last_up_to_pos(Evas_Coord x_, Evas_Coord y_)
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_last_up_to_pos(x_, y_));
            return _tmp_ret;
      }

      virtual int char_coords_get(Evas_Coord x_, Evas_Coord y_, Evas_Coord* cx_, Evas_Coord* cy_, Evas_Coord* cw_, Evas_Coord* ch_)
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_char_coords_get(x_, y_, cx_, cy_, cw_, ch_));
            return _tmp_ret;
      }

      virtual bool char_pos_get(int pos_, Evas_Coord* cx_, Evas_Coord* cy_, Evas_Coord* cw_, Evas_Coord* ch_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_char_pos_get(pos_, cx_, cy_, cw_, ch_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual std::string font_source_get()
      {
         const char * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_font_source_get());
            return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void font_source_set(std::string font_source_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_font_source_set(efl::eolian::to_c(font_source_)));
      }

      virtual void shadow_color_get(int* r_, int* g_, int* b_, int* a_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_shadow_color_get(r_, g_, b_, a_));
      }

      virtual void shadow_color_set(int r_, int g_, int b_, int a_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_shadow_color_set(r_, g_, b_, a_));
      }

      virtual double ellipsis_get()
      {
         double _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_ellipsis_get());
            return _tmp_ret;
      }

      virtual void ellipsis_set(double ellipsis_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_ellipsis_set(ellipsis_));
      }

      virtual std::string bidi_delimiters_get()
      {
         const char * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_bidi_delimiters_get());
            return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void bidi_delimiters_set(std::string delim_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_bidi_delimiters_set(efl::eolian::to_c(delim_)));
      }

      virtual void outline_color_get(int* r_, int* g_, int* b_, int* a_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_outline_color_get(r_, g_, b_, a_));
      }

      virtual void outline_color_set(int r_, int g_, int b_, int a_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_outline_color_set(r_, g_, b_, a_));
      }

      virtual std::string text_get()
      {
         const char * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_get());
            return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void text_set(std::string text_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_set(efl::eolian::to_c(text_)));
      }

      virtual void glow2_color_get(int* r_, int* g_, int* b_, int* a_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_glow2_color_get(r_, g_, b_, a_));
      }

      virtual void glow2_color_set(int r_, int g_, int b_, int a_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_glow2_color_set(r_, g_, b_, a_));
      }

      virtual void font_get(const char ** font_, Evas_Font_Size* size_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_font_get(font_, size_));
      }

      virtual void font_set(std::string font_, Evas_Font_Size size_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_font_set(efl::eolian::to_c(font_), size_));
      }

      virtual Evas_Text_Style_Type style_get()
      {
         Evas_Text_Style_Type _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_style_get());
            return _tmp_ret;
      }

      virtual void style_set(Evas_Text_Style_Type style_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_style_set(style_));
      }

      virtual void glow_color_get(int* r_, int* g_, int* b_, int* a_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_glow_color_get(r_, g_, b_, a_));
      }

      virtual void glow_color_set(int r_, int g_, int b_, int a_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_glow_color_set(r_, g_, b_, a_));
      }

      virtual void filter_program_set(std::string program_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_filter_program_set(efl::eolian::to_c(program_)));
      }

      virtual void filter_source_set(std::string name_, Eo * eobj_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_filter_source_set(efl::eolian::to_c(name_), eobj_));
      }

      virtual Evas_Coord max_descent_get()
      {
         Evas_Coord _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_max_descent_get());
            return _tmp_ret;
      }

      virtual void style_pad_get(int* l_, int* r_, int* t_, int* b_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_text_style_pad_get(l_, r_, t_, b_));
      }

      virtual Evas_BiDi_Direction direction_get()
      {
         Evas_BiDi_Direction _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_direction_get());
            return _tmp_ret;
      }

      virtual Evas_Coord ascent_get()
      {
         Evas_Coord _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_ascent_get());
            return _tmp_ret;
      }

      virtual Evas_Coord horiz_advance_get()
      {
         Evas_Coord _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_horiz_advance_get());
            return _tmp_ret;
      }

      virtual Evas_Coord inset_get()
      {
         Evas_Coord _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_inset_get());
            return _tmp_ret;
      }

      virtual Evas_Coord max_ascent_get()
      {
         Evas_Coord _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_max_ascent_get());
            return _tmp_ret;
      }

      virtual Evas_Coord vert_advance_get()
      {
         Evas_Coord _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_vert_advance_get());
            return _tmp_ret;
      }

      virtual Evas_Coord descent_get()
      {
         Evas_Coord _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_text_descent_get());
            return _tmp_ret;
      }

   };
};


template<>
struct operation_description_class_size< evas::text >
{
   static const int value = 34;
};

template <typename T>
int initialize_operation_description(efl::eo::detail::tag<evas::text>
                                 , Eo_Op_Description* ops)
{
   (void)ops;
   ops[0].func = reinterpret_cast<void*>(& ::evas_text_last_up_to_pos_wrapper<T>);
   ops[0].api_func = reinterpret_cast<void*>(& ::evas_obj_text_last_up_to_pos);
   ops[0].op = EO_OP_OVERRIDE;
   ops[0].op_type = EO_OP_TYPE_REGULAR;
   ops[0].doc = NULL;

   ops[1].func = reinterpret_cast<void*>(& ::evas_text_char_coords_get_wrapper<T>);
   ops[1].api_func = reinterpret_cast<void*>(& ::evas_obj_text_char_coords_get);
   ops[1].op = EO_OP_OVERRIDE;
   ops[1].op_type = EO_OP_TYPE_REGULAR;
   ops[1].doc = NULL;

   ops[2].func = reinterpret_cast<void*>(& ::evas_text_char_pos_get_wrapper<T>);
   ops[2].api_func = reinterpret_cast<void*>(& ::evas_obj_text_char_pos_get);
   ops[2].op = EO_OP_OVERRIDE;
   ops[2].op_type = EO_OP_TYPE_REGULAR;
   ops[2].doc = NULL;

   ops[3].func = reinterpret_cast<void*>(& ::evas_text_font_source_get_wrapper<T>);
   ops[3].api_func = reinterpret_cast<void*>(& ::evas_obj_text_font_source_get);
   ops[3].op = EO_OP_OVERRIDE;
   ops[3].op_type = EO_OP_TYPE_REGULAR;
   ops[3].doc = NULL;

   ops[4].func = reinterpret_cast<void*>(& ::evas_text_font_source_set_wrapper<T>);
   ops[4].api_func = reinterpret_cast<void*>(& ::evas_obj_text_font_source_set);
   ops[4].op = EO_OP_OVERRIDE;
   ops[4].op_type = EO_OP_TYPE_REGULAR;
   ops[4].doc = NULL;

   ops[5].func = reinterpret_cast<void*>(& ::evas_text_shadow_color_get_wrapper<T>);
   ops[5].api_func = reinterpret_cast<void*>(& ::evas_obj_text_shadow_color_get);
   ops[5].op = EO_OP_OVERRIDE;
   ops[5].op_type = EO_OP_TYPE_REGULAR;
   ops[5].doc = NULL;

   ops[6].func = reinterpret_cast<void*>(& ::evas_text_shadow_color_set_wrapper<T>);
   ops[6].api_func = reinterpret_cast<void*>(& ::evas_obj_text_shadow_color_set);
   ops[6].op = EO_OP_OVERRIDE;
   ops[6].op_type = EO_OP_TYPE_REGULAR;
   ops[6].doc = NULL;

   ops[7].func = reinterpret_cast<void*>(& ::evas_text_ellipsis_get_wrapper<T>);
   ops[7].api_func = reinterpret_cast<void*>(& ::evas_obj_text_ellipsis_get);
   ops[7].op = EO_OP_OVERRIDE;
   ops[7].op_type = EO_OP_TYPE_REGULAR;
   ops[7].doc = NULL;

   ops[8].func = reinterpret_cast<void*>(& ::evas_text_ellipsis_set_wrapper<T>);
   ops[8].api_func = reinterpret_cast<void*>(& ::evas_obj_text_ellipsis_set);
   ops[8].op = EO_OP_OVERRIDE;
   ops[8].op_type = EO_OP_TYPE_REGULAR;
   ops[8].doc = NULL;

   ops[9].func = reinterpret_cast<void*>(& ::evas_text_bidi_delimiters_get_wrapper<T>);
   ops[9].api_func = reinterpret_cast<void*>(& ::evas_obj_text_bidi_delimiters_get);
   ops[9].op = EO_OP_OVERRIDE;
   ops[9].op_type = EO_OP_TYPE_REGULAR;
   ops[9].doc = NULL;

   ops[10].func = reinterpret_cast<void*>(& ::evas_text_bidi_delimiters_set_wrapper<T>);
   ops[10].api_func = reinterpret_cast<void*>(& ::evas_obj_text_bidi_delimiters_set);
   ops[10].op = EO_OP_OVERRIDE;
   ops[10].op_type = EO_OP_TYPE_REGULAR;
   ops[10].doc = NULL;

   ops[11].func = reinterpret_cast<void*>(& ::evas_text_outline_color_get_wrapper<T>);
   ops[11].api_func = reinterpret_cast<void*>(& ::evas_obj_text_outline_color_get);
   ops[11].op = EO_OP_OVERRIDE;
   ops[11].op_type = EO_OP_TYPE_REGULAR;
   ops[11].doc = NULL;

   ops[12].func = reinterpret_cast<void*>(& ::evas_text_outline_color_set_wrapper<T>);
   ops[12].api_func = reinterpret_cast<void*>(& ::evas_obj_text_outline_color_set);
   ops[12].op = EO_OP_OVERRIDE;
   ops[12].op_type = EO_OP_TYPE_REGULAR;
   ops[12].doc = NULL;

   ops[13].func = reinterpret_cast<void*>(& ::evas_text_text_get_wrapper<T>);
   ops[13].api_func = reinterpret_cast<void*>(& ::evas_obj_text_get);
   ops[13].op = EO_OP_OVERRIDE;
   ops[13].op_type = EO_OP_TYPE_REGULAR;
   ops[13].doc = NULL;

   ops[14].func = reinterpret_cast<void*>(& ::evas_text_text_set_wrapper<T>);
   ops[14].api_func = reinterpret_cast<void*>(& ::evas_obj_text_set);
   ops[14].op = EO_OP_OVERRIDE;
   ops[14].op_type = EO_OP_TYPE_REGULAR;
   ops[14].doc = NULL;

   ops[15].func = reinterpret_cast<void*>(& ::evas_text_glow2_color_get_wrapper<T>);
   ops[15].api_func = reinterpret_cast<void*>(& ::evas_obj_text_glow2_color_get);
   ops[15].op = EO_OP_OVERRIDE;
   ops[15].op_type = EO_OP_TYPE_REGULAR;
   ops[15].doc = NULL;

   ops[16].func = reinterpret_cast<void*>(& ::evas_text_glow2_color_set_wrapper<T>);
   ops[16].api_func = reinterpret_cast<void*>(& ::evas_obj_text_glow2_color_set);
   ops[16].op = EO_OP_OVERRIDE;
   ops[16].op_type = EO_OP_TYPE_REGULAR;
   ops[16].doc = NULL;

   ops[17].func = reinterpret_cast<void*>(& ::evas_text_font_get_wrapper<T>);
   ops[17].api_func = reinterpret_cast<void*>(& ::evas_obj_text_font_get);
   ops[17].op = EO_OP_OVERRIDE;
   ops[17].op_type = EO_OP_TYPE_REGULAR;
   ops[17].doc = NULL;

   ops[18].func = reinterpret_cast<void*>(& ::evas_text_font_set_wrapper<T>);
   ops[18].api_func = reinterpret_cast<void*>(& ::evas_obj_text_font_set);
   ops[18].op = EO_OP_OVERRIDE;
   ops[18].op_type = EO_OP_TYPE_REGULAR;
   ops[18].doc = NULL;

   ops[19].func = reinterpret_cast<void*>(& ::evas_text_style_get_wrapper<T>);
   ops[19].api_func = reinterpret_cast<void*>(& ::evas_obj_text_style_get);
   ops[19].op = EO_OP_OVERRIDE;
   ops[19].op_type = EO_OP_TYPE_REGULAR;
   ops[19].doc = NULL;

   ops[20].func = reinterpret_cast<void*>(& ::evas_text_style_set_wrapper<T>);
   ops[20].api_func = reinterpret_cast<void*>(& ::evas_obj_text_style_set);
   ops[20].op = EO_OP_OVERRIDE;
   ops[20].op_type = EO_OP_TYPE_REGULAR;
   ops[20].doc = NULL;

   ops[21].func = reinterpret_cast<void*>(& ::evas_text_glow_color_get_wrapper<T>);
   ops[21].api_func = reinterpret_cast<void*>(& ::evas_obj_text_glow_color_get);
   ops[21].op = EO_OP_OVERRIDE;
   ops[21].op_type = EO_OP_TYPE_REGULAR;
   ops[21].doc = NULL;

   ops[22].func = reinterpret_cast<void*>(& ::evas_text_glow_color_set_wrapper<T>);
   ops[22].api_func = reinterpret_cast<void*>(& ::evas_obj_text_glow_color_set);
   ops[22].op = EO_OP_OVERRIDE;
   ops[22].op_type = EO_OP_TYPE_REGULAR;
   ops[22].doc = NULL;

   ops[23].func = reinterpret_cast<void*>(& ::evas_text_filter_program_set_wrapper<T>);
   ops[23].api_func = reinterpret_cast<void*>(& ::evas_obj_text_filter_program_set);
   ops[23].op = EO_OP_OVERRIDE;
   ops[23].op_type = EO_OP_TYPE_REGULAR;
   ops[23].doc = NULL;

   ops[24].func = reinterpret_cast<void*>(& ::evas_text_filter_source_set_wrapper<T>);
   ops[24].api_func = reinterpret_cast<void*>(& ::evas_obj_text_filter_source_set);
   ops[24].op = EO_OP_OVERRIDE;
   ops[24].op_type = EO_OP_TYPE_REGULAR;
   ops[24].doc = NULL;

   ops[25].func = reinterpret_cast<void*>(& ::evas_text_max_descent_get_wrapper<T>);
   ops[25].api_func = reinterpret_cast<void*>(& ::evas_obj_text_max_descent_get);
   ops[25].op = EO_OP_OVERRIDE;
   ops[25].op_type = EO_OP_TYPE_REGULAR;
   ops[25].doc = NULL;

   ops[26].func = reinterpret_cast<void*>(& ::evas_text_style_pad_get_wrapper<T>);
   ops[26].api_func = reinterpret_cast<void*>(& ::evas_obj_text_style_pad_get);
   ops[26].op = EO_OP_OVERRIDE;
   ops[26].op_type = EO_OP_TYPE_REGULAR;
   ops[26].doc = NULL;

   ops[27].func = reinterpret_cast<void*>(& ::evas_text_direction_get_wrapper<T>);
   ops[27].api_func = reinterpret_cast<void*>(& ::evas_obj_text_direction_get);
   ops[27].op = EO_OP_OVERRIDE;
   ops[27].op_type = EO_OP_TYPE_REGULAR;
   ops[27].doc = NULL;

   ops[28].func = reinterpret_cast<void*>(& ::evas_text_ascent_get_wrapper<T>);
   ops[28].api_func = reinterpret_cast<void*>(& ::evas_obj_text_ascent_get);
   ops[28].op = EO_OP_OVERRIDE;
   ops[28].op_type = EO_OP_TYPE_REGULAR;
   ops[28].doc = NULL;

   ops[29].func = reinterpret_cast<void*>(& ::evas_text_horiz_advance_get_wrapper<T>);
   ops[29].api_func = reinterpret_cast<void*>(& ::evas_obj_text_horiz_advance_get);
   ops[29].op = EO_OP_OVERRIDE;
   ops[29].op_type = EO_OP_TYPE_REGULAR;
   ops[29].doc = NULL;

   ops[30].func = reinterpret_cast<void*>(& ::evas_text_inset_get_wrapper<T>);
   ops[30].api_func = reinterpret_cast<void*>(& ::evas_obj_text_inset_get);
   ops[30].op = EO_OP_OVERRIDE;
   ops[30].op_type = EO_OP_TYPE_REGULAR;
   ops[30].doc = NULL;

   ops[31].func = reinterpret_cast<void*>(& ::evas_text_max_ascent_get_wrapper<T>);
   ops[31].api_func = reinterpret_cast<void*>(& ::evas_obj_text_max_ascent_get);
   ops[31].op = EO_OP_OVERRIDE;
   ops[31].op_type = EO_OP_TYPE_REGULAR;
   ops[31].doc = NULL;

   ops[32].func = reinterpret_cast<void*>(& ::evas_text_vert_advance_get_wrapper<T>);
   ops[32].api_func = reinterpret_cast<void*>(& ::evas_obj_text_vert_advance_get);
   ops[32].op = EO_OP_OVERRIDE;
   ops[32].op_type = EO_OP_TYPE_REGULAR;
   ops[32].doc = NULL;

   ops[33].func = reinterpret_cast<void*>(& ::evas_text_descent_get_wrapper<T>);
   ops[33].api_func = reinterpret_cast<void*>(& ::evas_obj_text_descent_get);
   ops[33].op = EO_OP_OVERRIDE;
   ops[33].op_type = EO_OP_TYPE_REGULAR;
   ops[33].doc = NULL;

   return 0;
}
inline void
call_constructor(tag< evas::text >
               , Eo* eo, Eo_Class const* cls EINA_UNUSED,
               args_class<evas::text, ::std::tuple<> > const& args)
{
   (void)args;
   eo_do_super(eo, cls, ::eo_constructor());
}

inline void
call_constructor(tag< evas::text >
               , Eo* eo, Eo_Class const* cls EINA_UNUSED,
               args_class<evas::text, ::std::tuple<efl::eo::parent_type> > const& args)
{
   eo_do_super(eo, cls, ::eo_constructor());
   eo_do(eo, ::eo_parent_set(args.get<0>()._eo_raw));
}

template<>
struct extension_inheritance< evas::text>
{
   template <typename U>
   struct type
   {
      operator evas::text() const
      {
         return evas::text(eo_ref(static_cast<U const*>(this)->_eo_ptr()));
      }

      int last_up_to_pos(Evas_Coord x_, Evas_Coord y_)
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_last_up_to_pos(x_, y_));
            return _tmp_ret;
      }

      int char_coords_get(Evas_Coord x_, Evas_Coord y_, Evas_Coord* cx_, Evas_Coord* cy_, Evas_Coord* cw_, Evas_Coord* ch_)
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_char_coords_get(x_, y_, cx_, cy_, cw_, ch_));
            return _tmp_ret;
      }

      bool char_pos_get(int pos_, Evas_Coord* cx_, Evas_Coord* cy_, Evas_Coord* cw_, Evas_Coord* ch_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_char_pos_get(pos_, cx_, cy_, cw_, ch_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      std::string font_source_get()
      {
         const char * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_font_source_get());
            return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
      }

      void font_source_set(std::string font_source_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_font_source_set(efl::eolian::to_c(font_source_)));
      }

      void shadow_color_get(int* r_, int* g_, int* b_, int* a_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_shadow_color_get(r_, g_, b_, a_));
      }

      void shadow_color_set(int r_, int g_, int b_, int a_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_shadow_color_set(r_, g_, b_, a_));
      }

      double ellipsis_get()
      {
         double _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_ellipsis_get());
            return _tmp_ret;
      }

      void ellipsis_set(double ellipsis_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_ellipsis_set(ellipsis_));
      }

      std::string bidi_delimiters_get()
      {
         const char * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_bidi_delimiters_get());
            return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
      }

      void bidi_delimiters_set(std::string delim_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_bidi_delimiters_set(efl::eolian::to_c(delim_)));
      }

      void outline_color_get(int* r_, int* g_, int* b_, int* a_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_outline_color_get(r_, g_, b_, a_));
      }

      void outline_color_set(int r_, int g_, int b_, int a_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_outline_color_set(r_, g_, b_, a_));
      }

      std::string text_get()
      {
         const char * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_get());
            return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
      }

      void text_set(std::string text_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_set(efl::eolian::to_c(text_)));
      }

      void glow2_color_get(int* r_, int* g_, int* b_, int* a_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_glow2_color_get(r_, g_, b_, a_));
      }

      void glow2_color_set(int r_, int g_, int b_, int a_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_glow2_color_set(r_, g_, b_, a_));
      }

      void font_get(const char ** font_, Evas_Font_Size* size_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_font_get(font_, size_));
      }

      void font_set(std::string font_, Evas_Font_Size size_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_font_set(efl::eolian::to_c(font_), size_));
      }

      Evas_Text_Style_Type style_get()
      {
         Evas_Text_Style_Type _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_style_get());
            return _tmp_ret;
      }

      void style_set(Evas_Text_Style_Type style_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_style_set(style_));
      }

      void glow_color_get(int* r_, int* g_, int* b_, int* a_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_glow_color_get(r_, g_, b_, a_));
      }

      void glow_color_set(int r_, int g_, int b_, int a_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_glow_color_set(r_, g_, b_, a_));
      }

      void filter_program_set(std::string program_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_filter_program_set(efl::eolian::to_c(program_)));
      }

      void filter_source_set(std::string name_, Eo * eobj_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_filter_source_set(efl::eolian::to_c(name_), eobj_));
      }

      Evas_Coord max_descent_get()
      {
         Evas_Coord _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_max_descent_get());
            return _tmp_ret;
      }

      void style_pad_get(int* l_, int* r_, int* t_, int* b_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_text_style_pad_get(l_, r_, t_, b_));
      }

      Evas_BiDi_Direction direction_get()
      {
         Evas_BiDi_Direction _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_direction_get());
            return _tmp_ret;
      }

      Evas_Coord ascent_get()
      {
         Evas_Coord _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_ascent_get());
            return _tmp_ret;
      }

      Evas_Coord horiz_advance_get()
      {
         Evas_Coord _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_horiz_advance_get());
            return _tmp_ret;
      }

      Evas_Coord inset_get()
      {
         Evas_Coord _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_inset_get());
            return _tmp_ret;
      }

      Evas_Coord max_ascent_get()
      {
         Evas_Coord _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_max_ascent_get());
            return _tmp_ret;
      }

      Evas_Coord vert_advance_get()
      {
         Evas_Coord _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_vert_advance_get());
            return _tmp_ret;
      }

      Evas_Coord descent_get()
      {
         Evas_Coord _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_text_descent_get());
            return _tmp_ret;
      }

   };
};

inline Eo_Class const* get_eo_class(tag<evas::text>)
{
   return (EVAS_TEXT_CLASS);
}

} } }
#endif // EFL_GENERATED_EVAS_TEXT_HH

