#ifndef EFL_GENERATED_EVAS_TEXTBLOCK_HH
#define EFL_GENERATED_EVAS_TEXTBLOCK_HH

#include <Eo.hh>

#include <eo_cxx_interop.hh>

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

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

namespace evas { 

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

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

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

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

   ~textblock() {}

   /// @brief Get the geometry of a line number.
   ///
   /// @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
   ///
   /// @param line the line number.
   /// @param[out] cx x coord of the line.
   /// @param[out] cy y coord of the line.
   /// @param[out] cw w coord of the line.
   /// @param[out] ch h coord of the line.
   ///
   bool line_number_geometry_get(int line_, 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_textblock_line_number_geometry_get(line_, cx_, cy_, cw_, ch_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Get the "replacement character" for given textblock object. Returns
   /// @c NULL if no replacement character is in use.
   ///
   /// @return Replacement character or @c NULL.
   ///
   std::string replace_char_get() const
   {
      const char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_textblock_replace_char_get());
      return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Del the from the top of the user style stack.
   ///
   /// @see evas_object_textblock_style_get
   /// @since 1.2
   ///
   void style_user_pop() const
   {
      eo_do(_eo_ptr(), ::evas_obj_textblock_style_user_pop());
   }

   /// @brief Create a new cursor, associate it to the obj and init it to point
   /// to the start of the textblock. Association to the object means the cursor
   /// will be updated when the object will change.
   ///
   /// @note if you need speed and you know what you are doing, it's slightly faster to just allocate the cursor yourself and not associate it. (only people developing the actual object, and not users of the object).
   ///
   /// @return the new cursor.
   ///
   Evas_Textblock_Cursor * cursor_new() const
   {
      Evas_Textblock_Cursor * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_textblock_cursor_new());
      return _tmp_ret;
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param anchor 
   ///
   const Eina_List * node_format_list_get(std::string anchor_) const
   {
      const Eina_List * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_textblock_node_format_list_get(efl::eolian::to_c(anchor_)));
      return _tmp_ret;
   }

   /// @brief Get (don't remove) the style at the top of the user style stack.
   ///
   /// @return the style of the object.
   /// @see evas_object_textblock_style_get
   /// @since 1.2
   ///
   const Evas_Textblock_Style * style_user_peek() const
   {
      const Evas_Textblock_Style * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_textblock_style_user_peek());
      return _tmp_ret;
   }

   /// @brief Remove a format node and its match.
   ///
   /// @param n 
   ///
   void node_format_remove_pair(Evas_Object_Textblock_Node_Format * n_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_textblock_node_format_remove_pair(n_));
   }

   /// @brief Clear the textblock object.
   /// @note Does *NOT* free the Evas object itself.
   ///
   /// @return nothing.
   ///
   void clear() const
   {
      eo_do(_eo_ptr(), ::evas_obj_textblock_clear());
   }

   /// @brief Push ts to the top of the user style stack.
   ///
   /// FIXME: API is solid but currently only supports 1 style in the stack.
   ///
   /// The user style overrides the corresponding elements of the regular style.
   /// This is the proper way to do theme overrides in code.
   /// @return Returns no value.
   /// @see evas_object_textblock_style_set
   /// @since 1.2
   ///
   /// @param ts the style to set.
   ///
   void style_user_push(Evas_Textblock_Style * ts_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_textblock_style_user_push(ts_));
   }

   /// @param text the markup text to use.
   ///
   std::string text_markup_get() const
   {
      const char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_textblock_text_markup_get());
      return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param text the markup text to use.
   ///
   void text_markup_set(std::string text_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_textblock_text_markup_set(efl::eolian::to_c(text_)));
   }

   /// @param align A value between @c 0.0 and @c 1.0.
   ///
   double valign_get() const
   {
      double _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_textblock_valign_get());
      return _tmp_ret;
   }

   /// @param align A value between @c 0.0 and @c 1.0.
   ///
   void valign_set(double align_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_textblock_valign_set(align_));
   }

   /// @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_textblock_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_textblock_bidi_delimiters_set(efl::eolian::to_c(delim_)));
   }

   /// @param ch The charset name.
   ///
   void replace_char_set(std::string ch_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_textblock_replace_char_set(efl::eolian::to_c(ch_)));
   }

   /// @param mode @c EINA_TRUE for legacy mode, @c EINA_FALSE otherwise.
   ///
   bool legacy_newline_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_textblock_legacy_newline_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param mode @c EINA_TRUE for legacy mode, @c EINA_FALSE otherwise.
   ///
   void legacy_newline_set(bool mode_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_textblock_legacy_newline_set(efl::eolian::to_c(mode_)));
   }

   /// @param ts the style to set.
   ///
   const Evas_Textblock_Style * style_get() const
   {
      const Evas_Textblock_Style * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_textblock_style_get());
      return _tmp_ret;
   }

   /// @param ts the style to set.
   ///
   void style_set(const Evas_Textblock_Style * ts_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_textblock_style_set(ts_));
   }

   /// @param format 
   ///
   const Evas_Object_Textblock_Node_Format * node_format_first_get() const
   {
      const Evas_Object_Textblock_Node_Format * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_textblock_node_format_first_get());
      return _tmp_ret;
   }

   /// @param w the width of the object.
   /// @param h the height of the object
   ///
   void size_formatted_get(Evas_Coord* w_, Evas_Coord* h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_textblock_size_formatted_get(w_, h_));
   }

   /// @param format 
   ///
   const Evas_Object_Textblock_Node_Format * node_format_last_get() const
   {
      const Evas_Object_Textblock_Node_Format * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_textblock_node_format_last_get());
      return _tmp_ret;
   }

   Evas_Textblock_Cursor * cursor_get() const
   {
      Evas_Textblock_Cursor * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_obj_textblock_cursor_get());
      return _tmp_ret;
   }

   /// @param w the width returned
   /// @param h the height returned
   ///
   void size_native_get(Evas_Coord* w_, Evas_Coord* h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_textblock_size_native_get(w_, h_));
   }

   /// @param l 
   /// @param r 
   /// @param t 
   /// @param b 
   ///
   void style_insets_get(Evas_Coord* l_, Evas_Coord* r_, Evas_Coord* t_, Evas_Coord* b_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_textblock_style_insets_get(l_, r_, t_, b_));
   }

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

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

};
} 

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

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

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

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

template <typename T>
const Eina_List * evas_textblock_node_format_list_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * anchor_)
{
   return static_cast<T*>(self->this_)->node_format_list_get(efl::eolian::to_cxx<std::string>(anchor_, std::tuple<std::false_type>()));
}

template <typename T>
const Evas_Textblock_Style * evas_textblock_style_user_peek_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->style_user_peek();
}

template <typename T>
void evas_textblock_node_format_remove_pair_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object_Textblock_Node_Format * n_)
{
   static_cast<T*>(self->this_)->node_format_remove_pair(n_);
}

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

template <typename T>
void evas_textblock_style_user_push_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Textblock_Style * ts_)
{
   static_cast<T*>(self->this_)->style_user_push(ts_);
}

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

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

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

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

template <typename T>
std::string evas_textblock_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_textblock_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_textblock_replace_char_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * ch_)
{
   static_cast<T*>(self->this_)->replace_char_set(efl::eolian::to_cxx<std::string>(ch_, std::tuple<std::false_type>()));
}

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

template <typename T>
void evas_textblock_legacy_newline_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool mode_)
{
   static_cast<T*>(self->this_)->legacy_newline_set(efl::eolian::to_cxx<bool>(mode_, std::tuple<std::false_type>()));
}

template <typename T>
const Evas_Textblock_Style * evas_textblock_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_textblock_style_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const Evas_Textblock_Style * ts_)
{
   static_cast<T*>(self->this_)->style_set(ts_);
}

template <typename T>
const Evas_Object_Textblock_Node_Format * evas_textblock_node_format_first_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->node_format_first_get();
}

template <typename T>
void evas_textblock_size_formatted_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* w_, Evas_Coord* h_)
{
   static_cast<T*>(self->this_)->size_formatted_get(w_, h_);
}

template <typename T>
const Evas_Object_Textblock_Node_Format * evas_textblock_node_format_last_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->node_format_last_get();
}

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

template <typename T>
void evas_textblock_size_native_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* w_, Evas_Coord* h_)
{
   static_cast<T*>(self->this_)->size_native_get(w_, h_);
}

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

namespace efl { namespace eo { namespace detail {

template<>
struct operations< evas::textblock >
{
   template <typename T>
   struct type
   {
      virtual bool line_number_geometry_get(int line_, 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_textblock_line_number_geometry_get(line_, cx_, cy_, cw_, ch_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      virtual void style_user_pop()
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_textblock_style_user_pop());
      }

      virtual Evas_Textblock_Cursor * cursor_new()
      {
         Evas_Textblock_Cursor * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_textblock_cursor_new());
            return _tmp_ret;
      }

      virtual const Eina_List * node_format_list_get(std::string anchor_)
      {
         const Eina_List * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_textblock_node_format_list_get(efl::eolian::to_c(anchor_)));
            return _tmp_ret;
      }

      virtual const Evas_Textblock_Style * style_user_peek()
      {
         const Evas_Textblock_Style * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_textblock_style_user_peek());
            return _tmp_ret;
      }

      virtual void node_format_remove_pair(Evas_Object_Textblock_Node_Format * n_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_textblock_node_format_remove_pair(n_));
      }

      virtual void clear()
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_textblock_clear());
      }

      virtual void style_user_push(Evas_Textblock_Style * ts_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_textblock_style_user_push(ts_));
      }

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

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

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

      virtual void valign_set(double align_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_textblock_valign_set(align_));
      }

      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_textblock_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_textblock_bidi_delimiters_set(efl::eolian::to_c(delim_)));
      }

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

      virtual bool legacy_newline_get()
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_textblock_legacy_newline_get());
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void legacy_newline_set(bool mode_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_textblock_legacy_newline_set(efl::eolian::to_c(mode_)));
      }

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

      virtual void style_set(const Evas_Textblock_Style * ts_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_textblock_style_set(ts_));
      }

      virtual const Evas_Object_Textblock_Node_Format * node_format_first_get()
      {
         const Evas_Object_Textblock_Node_Format * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_textblock_node_format_first_get());
            return _tmp_ret;
      }

      virtual void size_formatted_get(Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_textblock_size_formatted_get(w_, h_));
      }

      virtual const Evas_Object_Textblock_Node_Format * node_format_last_get()
      {
         const Evas_Object_Textblock_Node_Format * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_textblock_node_format_last_get());
            return _tmp_ret;
      }

      virtual Evas_Textblock_Cursor * cursor_get()
      {
         Evas_Textblock_Cursor * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_obj_textblock_cursor_get());
            return _tmp_ret;
      }

      virtual void size_native_get(Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_textblock_size_native_get(w_, h_));
      }

      virtual void style_insets_get(Evas_Coord* l_, Evas_Coord* r_, Evas_Coord* t_, Evas_Coord* b_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_textblock_style_insets_get(l_, r_, t_, b_));
      }

   };
};


template<>
struct operation_description_class_size< evas::textblock >
{
   static const int value = 26;
};

template <typename T>
int initialize_operation_description(efl::eo::detail::tag<evas::textblock>
                                 , Eo_Op_Description* ops)
{
   (void)ops;
   ops[0].func = reinterpret_cast<void*>(& ::evas_textblock_line_number_geometry_get_wrapper<T>);
   ops[0].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_line_number_geometry_get);
   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_textblock_replace_char_get_wrapper<T>);
   ops[1].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_replace_char_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_textblock_style_user_pop_wrapper<T>);
   ops[2].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_style_user_pop);
   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_textblock_cursor_new_wrapper<T>);
   ops[3].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_cursor_new);
   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_textblock_node_format_list_get_wrapper<T>);
   ops[4].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_node_format_list_get);
   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_textblock_style_user_peek_wrapper<T>);
   ops[5].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_style_user_peek);
   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_textblock_node_format_remove_pair_wrapper<T>);
   ops[6].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_node_format_remove_pair);
   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_textblock_clear_wrapper<T>);
   ops[7].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_clear);
   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_textblock_style_user_push_wrapper<T>);
   ops[8].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_style_user_push);
   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_textblock_text_markup_get_wrapper<T>);
   ops[9].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_text_markup_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_textblock_text_markup_set_wrapper<T>);
   ops[10].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_text_markup_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_textblock_valign_get_wrapper<T>);
   ops[11].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_valign_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_textblock_valign_set_wrapper<T>);
   ops[12].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_valign_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_textblock_bidi_delimiters_get_wrapper<T>);
   ops[13].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_bidi_delimiters_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_textblock_bidi_delimiters_set_wrapper<T>);
   ops[14].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_bidi_delimiters_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_textblock_replace_char_set_wrapper<T>);
   ops[15].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_replace_char_set);
   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_textblock_legacy_newline_get_wrapper<T>);
   ops[16].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_legacy_newline_get);
   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_textblock_legacy_newline_set_wrapper<T>);
   ops[17].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_legacy_newline_set);
   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_textblock_style_get_wrapper<T>);
   ops[18].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_style_get);
   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_textblock_style_set_wrapper<T>);
   ops[19].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_style_set);
   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_textblock_node_format_first_get_wrapper<T>);
   ops[20].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_node_format_first_get);
   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_textblock_size_formatted_get_wrapper<T>);
   ops[21].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_size_formatted_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_textblock_node_format_last_get_wrapper<T>);
   ops[22].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_node_format_last_get);
   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_textblock_cursor_get_wrapper<T>);
   ops[23].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_cursor_get);
   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_textblock_size_native_get_wrapper<T>);
   ops[24].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_size_native_get);
   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_textblock_style_insets_get_wrapper<T>);
   ops[25].api_func = reinterpret_cast<void*>(& ::evas_obj_textblock_style_insets_get);
   ops[25].op = EO_OP_OVERRIDE;
   ops[25].op_type = EO_OP_TYPE_REGULAR;
   ops[25].doc = NULL;

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

inline void
call_constructor(tag< evas::textblock >
               , Eo* eo, Eo_Class const* cls EINA_UNUSED,
               args_class<evas::textblock, ::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::textblock>
{
   template <typename U>
   struct type
   {
      operator evas::textblock() const
      {
         return evas::textblock(eo_ref(static_cast<U const*>(this)->_eo_ptr()));
      }

      bool line_number_geometry_get(int line_, 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_textblock_line_number_geometry_get(line_, cx_, cy_, cw_, ch_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      void style_user_pop()
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_textblock_style_user_pop());
      }

      Evas_Textblock_Cursor * cursor_new()
      {
         Evas_Textblock_Cursor * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_textblock_cursor_new());
            return _tmp_ret;
      }

      const Eina_List * node_format_list_get(std::string anchor_)
      {
         const Eina_List * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_textblock_node_format_list_get(efl::eolian::to_c(anchor_)));
            return _tmp_ret;
      }

      const Evas_Textblock_Style * style_user_peek()
      {
         const Evas_Textblock_Style * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_textblock_style_user_peek());
            return _tmp_ret;
      }

      void node_format_remove_pair(Evas_Object_Textblock_Node_Format * n_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_textblock_node_format_remove_pair(n_));
      }

      void clear()
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_textblock_clear());
      }

      void style_user_push(Evas_Textblock_Style * ts_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_textblock_style_user_push(ts_));
      }

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

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

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

      void valign_set(double align_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_textblock_valign_set(align_));
      }

      std::string bidi_delimiters_get()
      {
         const char * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_textblock_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_textblock_bidi_delimiters_set(efl::eolian::to_c(delim_)));
      }

      void replace_char_set(std::string ch_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_textblock_replace_char_set(efl::eolian::to_c(ch_)));
      }

      bool legacy_newline_get()
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_textblock_legacy_newline_get());
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void legacy_newline_set(bool mode_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_textblock_legacy_newline_set(efl::eolian::to_c(mode_)));
      }

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

      void style_set(const Evas_Textblock_Style * ts_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_textblock_style_set(ts_));
      }

      const Evas_Object_Textblock_Node_Format * node_format_first_get()
      {
         const Evas_Object_Textblock_Node_Format * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_textblock_node_format_first_get());
            return _tmp_ret;
      }

      void size_formatted_get(Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_textblock_size_formatted_get(w_, h_));
      }

      const Evas_Object_Textblock_Node_Format * node_format_last_get()
      {
         const Evas_Object_Textblock_Node_Format * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_textblock_node_format_last_get());
            return _tmp_ret;
      }

      Evas_Textblock_Cursor * cursor_get()
      {
         Evas_Textblock_Cursor * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_obj_textblock_cursor_get());
            return _tmp_ret;
      }

      void size_native_get(Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_textblock_size_native_get(w_, h_));
      }

      void style_insets_get(Evas_Coord* l_, Evas_Coord* r_, Evas_Coord* t_, Evas_Coord* b_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_textblock_style_insets_get(l_, r_, t_, b_));
      }

   };
};

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

} } }
#endif // EFL_GENERATED_EVAS_TEXTBLOCK_HH

