#ifndef EFL_GENERATED_EDJE_OBJECT_HH
#define EFL_GENERATED_EDJE_OBJECT_HH

extern "C"
{
#include <Efl.h>
}
#include <Eo.hh>

#include <eo_cxx_interop.hh>

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

#include "evas_smart_clipped.eo.hh"
#include "efl_file.eo.hh"
#include <canvas/evas_object.eo.hh>
#include <string>

namespace edje {

struct object
      : evas::smart_clipped,
      efl::eo::detail::extension_inheritance<efl::file>::template type< ::edje::object>

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

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

   /// @brief Call the object's constructor.
   /// Should not be used with #eo_do. Only use it with #eo_do_super.
   ///
   object(efl::eo::parent_type _p = (efl::eo::parent = nullptr))
      : object(_c0(_p))
   {}

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

   ~object() {}

   /// @brief Get dbg information from the object.
   ///
   /// @param root_node node of the tree
   ///
   void dbg_info_get(Eo_Dbg_Info * root_node_) const
   {
      eo_do(_eo_ptr(), ::eo_dbg_info_get(root_node_));
   }

   /// @brief No description supplied by the EAPI.
   ///
   void hide() const
   {
      eo_do(_eo_ptr(), ::evas_obj_smart_hide());
   }

   /// @brief Call the @b calculate() smart function immediately on a given smart
   /// object.
   ///
   /// This will force immediate calculations (see #Evas_Smart_Class)
   /// needed for renderization of this object and, besides, unset the
   /// flag on it telling it needs recalculation for the next rendering
   /// phase.
   ///
   /// @see evas_object_smart_need_recalculate_set()
   ///
   /// @ingroup Evas_Smart_Object_Group
   ///
   void calculate() const
   {
      eo_do(_eo_ptr(), ::evas_obj_smart_calculate());
   }

   /// @brief No description supplied by the EAPI.
   ///
   void show() const
   {
      eo_do(_eo_ptr(), ::evas_obj_smart_show());
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param x 
   /// @param y 
   ///
   void move(Evas_Coord x_, Evas_Coord y_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_smart_move(x_, y_));
   }

   /// @brief Instantiates a new smart object described by @p s.
   ///
   /// @return a new #Evas_Object handle
   ///
   /// This is the function one should use when defining the public
   /// function @b adding an instance of the new smart object to a given
   /// canvas. It will take care of setting all of its internals to work
   /// as they should, if the user set things properly, as seem on the
   /// #EVAS_SMART_SUBCLASS_NEW, for example.
   ///
   /// @ingroup Evas_Smart_Object_Group
   ///
   void add() const
   {
      eo_do(_eo_ptr(), ::evas_obj_smart_add());
   }

   /// @brief Deletes a smart object.
   ///
   void del() const
   {
      eo_do(_eo_ptr(), ::evas_obj_smart_del());
   }

   /// @brief No description supplied by the EAPI.
   ///
   /// @param w 
   /// @param h 
   ///
   void resize(Evas_Coord w_, Evas_Coord h_) const
   {
      eo_do(_eo_ptr(), ::evas_obj_smart_resize(w_, h_));
   }

   /// @brief Set the source file from where an image object must fetch the real
   /// image data (it may be an Eet file, besides pure image ones).
   ///
   /// If the file supports multiple data stored in it (as Eet files do),
   /// you can specify the key to be used as the index of the image in
   /// this file.
   ///
   /// Example:
   /// @code
   /// img = evas_object_image_add(canvas);
   /// evas_object_image_file_set(img, "/path/to/img", NULL);
   /// err = evas_object_image_load_error_get(img);
   /// if (err != EVAS_LOAD_ERROR_NONE)
   /// {
   /// fprintf(stderr, "could not load image '%s'. error string is \"%s\"\n",
   /// valid_path, evas_load_error_str(err));
   /// }
   /// else
   /// {
   /// evas_object_image_fill_set(img, 0, 0, w, h);
   /// evas_object_resize(img, w, h);
   /// evas_object_show(img);
   /// }
   /// @endcode
   ///
   /// @param file The image file path.
   /// @param key The image key in @p file (if its an Eet one), or @c
   /// NULL, otherwise.
   ///
   bool file_set(std::string file_, std::string key_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::efl_file_set(efl::eolian::to_c(file_), efl::eolian::to_c(key_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Retrieve the source file from where an image object is to fetch the
   /// real image data (it may be an Eet file, besides pure image ones).
   ///
   /// You must @b not modify the strings on the returned pointers.
   ///
   /// @note Use @c NULL pointers on the file components you're not
   /// interested in: they'll be ignored by the function.
   ///
   /// @param file The image file path.
   /// @param key The image key in @p file (if its an Eet one), or @c
   /// NULL, otherwise.
   ///
   void file_get(const char ** file_, const char ** key_) const
   {
      eo_do(_eo_ptr(), ::efl_file_get(file_, key_));
   }

   /// @brief @brief Whether or not Edje will update size hints on itself.
   ///
   /// @return @c true if does, @c false if it doesn't.
   ///
   /// @param update Whether or not update the size hints.
   ///
   bool update_hints_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_update_hints_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Edje will automatically update the size hints on itself.
   ///
   /// By default edje doesn't set size hints on itself. With this function
   /// call, it will do so if update is true. Be carefully, it cost a lot to
   /// trigger this feature as it will recalc the object every time it make
   /// sense to be sure that's its minimal size hint is always accurate.
   ///
   /// @param update Whether or not update the size hints.
   ///
   void update_hints_set(bool update_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_update_hints_set(efl::eolian::to_c(update_)));
   }

   /// @brief @brief Get the RTL orientation for this object.
   ///
   /// You can RTL orientation explicitly with edje_object_mirrored_set.
   ///
   /// @return @c EINA_TRUE if the flag is set or @c EINA_FALSE if not.
   /// @since 1.1.0
   ///
   /// @param rtl new value of flag EINA_TRUE/EINA_FALSE
   ///
   bool mirrored_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_mirrored_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Set the RTL orientation for this object.
   ///
   /// @since 1.1.0
   ///
   /// @param rtl new value of flag EINA_TRUE/EINA_FALSE
   ///
   void mirrored_set(bool rtl_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_mirrored_set(efl::eolian::to_c(rtl_)));
   }

   /// @brief @brief Get the Edje object's animation state.
   ///
   /// @return @c EINA_FALSE on error or if object is not animated;
   /// @c EINA_TRUE if animated.
   ///
   /// This function returns if the animation is stopped or not. The
   /// animation state is set by edje_object_animation_set().
   ///
   /// @see edje_object_animation_set().
   ///
   /// @param on The animation state. @c EINA_TRUE to starts or
   /// @c EINA_FALSE to stops.
   ///
   bool animation_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_animation_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Set the object's animation state.
   ///
   /// This function starts or stops an Edje object's animation. The
   /// information if it's stopped can be retrieved by
   /// edje_object_animation_get().
   ///
   /// @see edje_object_animation_get()
   ///
   /// @param on The animation state. @c EINA_TRUE to starts or
   /// @c EINA_FALSE to stops.
   ///
   void animation_set(bool on_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_animation_set(efl::eolian::to_c(on_)));
   }

   /// @brief @brief Get the Edje object's state.
   ///
   /// @return @c EINA_FALSE if the object is not connected, its @c delete_me flag
   /// is set, or it is at paused state; @c EINA_TRUE if the object is at playing
   /// state.
   ///
   /// This function tells if an Edje object is playing or not. This state
   /// is set by edje_object_play_set().
   ///
   /// @see edje_object_play_set().
   ///
   /// @param play Object state (@c EINA_TRUE to playing,
   /// @c EINA_FALSE to paused).
   ///
   bool play_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_play_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Set the Edje object to playing or paused states.
   ///
   /// This function sets the Edje object @a obj to playing or paused
   /// states, depending on the parameter @a play. This has no effect if
   /// the object was already at that state.
   ///
   /// @see edje_object_play_get().
   ///
   /// @param play Object state (@c EINA_TRUE to playing,
   /// @c EINA_FALSE to paused).
   ///
   void play_set(bool play_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_play_set(efl::eolian::to_c(play_)));
   }

   /// @brief Get the current perspective used on this Edje object.
   ///
   /// @return The perspective object being used on this Edje object. Or @c NULL
   /// if there was none, and on errors.
   ///
   /// @see edje_object_perspective_set()
   ///
   /// @param ps The perspective object that will be used.
   ///
   const Edje_Perspective * perspective_get() const
   {
      const Edje_Perspective * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_perspective_get());
      return _tmp_ret;
   }

   /// @brief Set the given perspective object on this Edje object.
   ///
   /// Make the given perspective object be the default perspective for this Edje
   /// object.
   ///
   /// There can be only one perspective object per Edje object, and if a
   /// previous one was set, it will be removed and the new perspective object
   /// will be used.
   ///
   /// An Edje perspective will only affect a part if it doesn't point to another
   /// part to be used as perspective.
   ///
   /// @see edje_object_perspective_new()
   /// @see edje_object_perspective_get()
   /// @see edje_perspective_set()
   ///
   /// @param ps The perspective object that will be used.
   ///
   void perspective_set(Edje_Perspective * ps_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_perspective_set(ps_));
   }

   /// @brief @brief Get a given Edje object's scaling factor.
   ///
   /// This function returns the @c individual scaling factor set on the
   /// @a obj Edje object.
   ///
   /// @see edje_object_scale_set() for more details
   ///
   /// @param scale The scaling factor (the default value is @c 0.0,
   /// meaning individual scaling @b not set)
   ///
   double scale_get() const
   {
      double _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_scale_get());
      return _tmp_ret;
   }

   /// @brief @brief Set the scaling factor for a given Edje object.
   ///
   /// This function sets an @b individual scaling factor on the @a obj
   /// Edje object. This property (or Edje's global scaling factor, when
   /// applicable), will affect this object's part sizes. If @p scale is
   /// not zero, than the individual scaling will @b override any global
   /// scaling set, for the object @p obj's parts. Put it back to zero to
   /// get the effects of the global scaling again.
   ///
   /// @warning Only parts which, at EDC level, had the @c "scale"
   /// property set to @c 1, will be affected by this function. Check the
   /// complete @ref edcref "syntax reference" for EDC files.
   ///
   /// @see edje_object_scale_get()
   /// @see edje_scale_get() for more details
   ///
   /// @param scale The scaling factor (the default value is @c 0.0,
   /// meaning individual scaling @b not set)
   ///
   bool scale_set(double scale_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_scale_set(scale_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Get a given Edje object's base_scale factor.
   ///
   /// This function returns the base_scale factor set on the
   /// @a obj Edje object.
   /// The base_scale can be set in the collection of edc.
   /// If it isn't set, the default value is 1.0
   ///
   /// @param base_scale 
   ///
   double base_scale_get() const
   {
      double _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_base_scale_get());
      return _tmp_ret;
   }

   /// @brief @brief Sets the @b EDJ file (and group within it) to load an Edje
   /// object's contents from
   ///
   /// @return @c EINA_TRUE, on success or @c EINA_FALSE, on errors (check
   /// edje_object_load_error_get() after this call to get errors causes)
   ///
   /// Edje expects EDJ files, which are theming objects' descriptions and
   /// resources packed together in an EET file, to read Edje object
   /// definitions from. They usually are created with the @c .edj
   /// extension. EDJ files, in turn, are assembled from @b textual object
   /// description files, where one describes Edje objects declaratively
   /// -- the EDC files (see @ref edcref "the syntax" for those files).
   ///
   /// Those description files were designed so that many Edje object
   /// definitions -- also called @b groups (or collections) -- could be
   /// packed together <b>in the same EDJ file</b>, so that a whole
   /// application's theme could be packed in one file only. This is the
   /// reason for the @p group argument.
   ///
   /// Use this function after you instantiate a new Edje object, so that
   /// you can "give him life", telling where to get its contents from.
   ///
   /// @see edje_object_add()
   /// @see edje_object_file_get()
   /// @see edje_object_mmap_set()
   /// @since 1.8
   ///
   /// @param file The Eina.File pointing to the EDJ file to load @p from
   /// @param group The name of the group, in @p file, which implements an
   /// Edje object
   ///
   bool mmap_set(const Eina_File * file_, std::string group_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_mmap_set(file_, efl::eolian::to_c(group_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Set the object text callback.
   ///
   /// This function sets the callback to be called when the text changes.
   ///
   /// @param func The callback function to handle the text change
   /// @param data The data associated to the callback function.
   ///
   void text_change_cb_set(Edje_Text_Change_Cb func_, void * data_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_text_change_cb_set(func_, data_));
   }

   /// @brief @brief Moves the cursor to the beginning of the text part
   /// @see evas_textblock_cursor_paragraph_first
   ///
   /// @param part The part name
   /// @param cur the edje cursor to work on
   ///
   void part_text_cursor_begin_set(std::string part_, Edje_Cursor cur_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_cursor_begin_set(efl::eolian::to_c(part_), cur_));
   }

   /// @brief @brief Move the cursor to the end of the line.
   /// @see evas_textblock_cursor_line_char_last
   ///
   /// @param part The part name
   /// @param cur the edje cursor to work on
   ///
   void part_text_cursor_line_end_set(std::string part_, Edje_Cursor cur_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_cursor_line_end_set(efl::eolian::to_c(part_), cur_));
   }

   /// @brief @brief Sets Edje text class.
   ///
   /// @return @c EINA_TRUE, on success or @c EINA_FALSE, on error
   ///
   /// This function sets the text class for the Edje.
   ///
   /// @param text_class The text class name
   /// @param font Font name
   /// @param size Font Size
   ///
   bool text_class_set(std::string text_class_, std::string font_, Evas_Font_Size size_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_text_class_set(efl::eolian::to_c(text_class_), efl::eolian::to_c(font_), size_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Position the given cursor to a X,Y position.
   ///
   /// This is frequently used with the user cursor.
   ///
   /// @return True on success, false on error.
   ///
   /// @param part The part containing the object.
   /// @param cur The cursor to adjust.
   /// @param x X Coordinate.
   /// @param y Y Coordinate.
   ///
   bool part_text_cursor_coord_set(std::string part_, Edje_Cursor cur_, Evas_Coord x_, Evas_Coord y_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_coord_set(efl::eolian::to_c(part_), cur_, x_, y_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Moves the cursor to the end of the text part.
   /// @see evas_textblock_cursor_paragraph_last
   ///
   /// @param part The part name
   /// @param cur the edje cursor to work on
   ///
   void part_text_cursor_end_set(std::string part_, Edje_Cursor cur_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_cursor_end_set(efl::eolian::to_c(part_), cur_));
   }

   /// @brief @brief Sets the text for an object part, but converts HTML escapes to UTF8
   ///
   /// This converts the given string @p text to UTF8 assuming it contains HTML
   /// style escapes like "&amp;" and "&copy;" etc. IF the part is of type TEXT,
   /// as opposed to TEXTBLOCK.
   ///
   /// @return @c EINA_TRUE on success, @c EINA_FALSE otherwise
   ///
   /// @since 1.2
   ///
   /// @param part The part name
   /// @param text The text string
   ///
   bool part_text_escaped_set(std::string part_, std::string text_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_escaped_set(efl::eolian::to_c(part_), efl::eolian::to_c(text_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Set the function that provides item objects for named items in an edje entry text
   ///
   /// Item objects may be deleted any time by Edje, and will be deleted when the
   /// Edje object is deleted (or file is set to a new file).
   ///
   /// @param func The function to call (or NULL to disable) to get item objects
   /// @param data The data pointer to pass to the @p func callback
   ///
   void item_provider_set(Edje_Item_Provider_Cb func_, void * data_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_item_provider_set(func_, data_));
   }

   /// @brief @brief Move the cursor to the beginning of the line.
   /// @see evas_textblock_cursor_line_char_first
   ///
   /// @param part The part name
   /// @param cur the edje cursor to work on
   ///
   void part_text_cursor_line_begin_set(std::string part_, Edje_Cursor cur_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_cursor_line_begin_set(efl::eolian::to_c(part_), cur_));
   }

   /// @brief @brief Set an Edje message handler function for a given Edje object.
   ///
   /// For scriptable programs on an Edje object's defining EDC file which
   /// send messages with the @c send_message() primitive, one can attach
   /// <b>handler functions</b>, to be called in the code which creates
   /// that object (see @ref edcref "the syntax" for EDC files).
   ///
   /// This function associates a message handler function and the
   /// attached data pointer to the object @p obj.
   ///
   /// @see edje_object_message_send()
   ///
   /// @param func The function to handle messages @b coming from @p obj
   /// @param data Auxiliary data to be passed to @p func
   ///
   void message_handler_set(Edje_Message_Handler_Cb func_, void * data_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_message_handler_set(func_, data_));
   }

   /// @brief @brief Get the minimum size specified -- as an EDC property -- for a
   /// given Edje object
   ///
   /// This function retrieves the @p obj object's minimum size values,
   /// <b>as declared in its EDC group definition</b>. Minimum size of
   /// groups have the following syntax
   /// @code
   /// collections {
   /// group {
   /// name: "a_group";
   /// min: 100 100;
   /// }
   /// }
   /// @endcode
   ///
   /// where one declares a minimum size of 100 pixels both for width and
   /// height. Those are (hint) values which should be respected when the
   /// given object/group is to be controlled by a given container object
   /// (e.g. an Edje object being "swallowed" into a given @c SWALLOW
   /// typed part, as in edje_object_part_swallow()). Check the complete
   /// @ref edcref "syntax reference" for EDC files.
   ///
   /// @note If the @c min EDC property was not declared for @p obj, this
   /// call will return the value 0, for each axis.
   ///
   /// @note On failure, this function will make all non-@c NULL size
   /// pointers' pointed variables be set to zero.
   ///
   /// @see edje_object_size_max_get()
   ///
   /// @param minw Pointer to a variable where to store the minimum width
   /// @param minh Pointer to a variable where to store the minimum height
   ///
   void size_min_get(Evas_Coord* minw_, Evas_Coord* minh_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_size_min_get(minw_, minh_));
   }

   /// @brief @brief Retrieve a list all accessibility part names
   ///
   /// @return A list all accessibility part names on @p obj
   /// @since 1.7.0
   ///
   efl::eina::range_list< std::string > access_part_list_get() const
   {
      Eina_List * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_access_part_list_get());
      return efl::eolian::to_cxx<efl::eina::range_list< std::string >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
   }

   /// @brief @brief Gets the (last) file loading error for a given Edje object
   ///
   /// @return The Edje loading error, one of:
   /// - #EDJE_LOAD_ERROR_NONE
   /// - #EDJE_LOAD_ERROR_GENERIC
   /// - #EDJE_LOAD_ERROR_DOES_NOT_EXIST
   /// - #EDJE_LOAD_ERROR_PERMISSION_DENIED
   /// - #EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED
   /// - #EDJE_LOAD_ERROR_CORRUPT_FILE
   /// - #EDJE_LOAD_ERROR_UNKNOWN_FORMAT
   /// - #EDJE_LOAD_ERROR_INCOMPATIBLE_FILE
   /// - #EDJE_LOAD_ERROR_UNKNOWN_COLLECTION
   /// - #EDJE_LOAD_ERROR_RECURSIVE_REFERENCE
   ///
   /// This function is meant to be used after an Edje EDJ <b>file
   /// loading</b>, what takes place with the edje_object_file_set()
   /// function. If that function does not return @c EINA_TRUE, one should
   /// check for the reason of failure with this one.
   ///
   /// @see edje_load_error_str()
   ///
   Edje_Load_Error load_error_get() const
   {
      Edje_Load_Error _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_load_error_get());
      return _tmp_ret;
   }

   /// @brief @brief Get the maximum size specified -- as an EDC property -- for a
   /// given Edje object
   ///
   /// This function retrieves the @p obj object's maximum size values,
   /// <b>as declared in its EDC group definition</b>. Maximum size of
   /// groups have the following syntax
   /// @code
   /// collections {
   /// group {
   /// name: "a_group";
   /// max: 100 100;
   /// }
   /// }
   /// @endcode
   ///
   /// where one declares a maximum size of 100 pixels both for width and
   /// height. Those are (hint) values which should be respected when the
   /// given object/group is to be controlled by a given container object
   /// (e.g. an Edje object being "swallowed" into a given @c SWALLOW
   /// typed part, as in edje_object_part_swallow()). Check the complete
   /// @ref edcref "syntax reference" for EDC files.
   ///
   /// @note If the @c max EDC property was not declared for @p obj, this
   /// call will return the maximum size a given Edje object may have, for
   /// each axis.
   ///
   /// @note On failure, this function will make all non-@c NULL size
   /// pointers' pointed variables be set to zero.
   ///
   /// @see edje_object_size_min_get()
   ///
   /// @param maxw Pointer to a variable where to store the maximum width
   /// @param maxh Pointer to a variable where to store the maximum height
   ///
   void size_max_get(Evas_Coord* maxw_, Evas_Coord* maxh_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_size_max_get(maxw_, maxh_));
   }

   /// @brief @brief Removes all object from the table.
   ///
   /// @return @c EINA_TRUE clear the table, @c EINA_FALSE on failure
   ///
   /// Removes all object from the table indicated by part, except the
   /// internal ones set from the theme.
   ///
   /// @param part The part name
   /// @param clear If set, will delete subobjs on remove
   ///
   bool part_table_clear(std::string part_, bool clear_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_table_clear(efl::eolian::to_c(part_), efl::eolian::to_c(clear_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Facility to query the type of the given parameter of the given part.
   ///
   /// @return @c EDJE_EXTERNAL_PARAM_TYPE_MAX on errors, or another value
   /// from #Edje_External_Param_Type on success.
   ///
   /// @param part The part name
   /// @param[out] param the parameter name to use.
   ///
   Edje_External_Param_Type part_external_param_type_get(std::string part_, const char* param_) const
   {
      Edje_External_Param_Type _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_external_param_type_get(efl::eolian::to_c(part_), param_));
      return _tmp_ret;
   }

   /// @brief @brief Enables selection if the entry is an EXPLICIT selection mode
   /// type.
   ///
   /// The default is to @b not allow selection. This function only affects user
   /// selection, functions such as edje_object_part_text_select_all() and
   /// edje_object_part_text_select_none() are not affected.
   ///
   /// @param part The part name
   /// @param allow EINA_TRUE to enable, EINA_FALSE otherwise
   ///
   void part_text_select_allow_set(std::string part_, bool allow_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_select_allow_set(efl::eolian::to_c(part_), efl::eolian::to_c(allow_)));
   }

   /// @brief @brief Returns the state of the Edje part.
   ///
   /// @return The part state:\n
   /// "default" for the default state\n
   /// "" for other states
   ///
   /// @param part The part name
   /// @param[out] val_ret 
   ///
   std::string part_state_get(std::string part_, double* val_ret_) const
   {
      const char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_state_get(efl::eolian::to_c(part_), val_ret_));
      return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Delete a function and matching user data from the markup filter list.
   ///
   /// Delete the given @p func filter and @p data user data from the list
   /// in @p part.
   /// Returns the user data pointer given when added.
   ///
   /// @see edje_object_text_markup_filter_callback_add
   /// @see edje_object_text_markup_filter_callback_del
   ///
   /// @return The same data pointer if successful, or NULL otherwise
   /// @since 1.2.0
   ///
   /// @param part The part name
   /// @param func The function callback to remove
   /// @param data The data passed to the callback function
   ///
   void * text_markup_filter_callback_del_full(std::string part_, Edje_Markup_Filter_Cb func_, void * data_) const
   {
      void * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_text_markup_filter_callback_del_full(efl::eolian::to_c(part_), func_, data_));
      return _tmp_ret;
   }

   /// @brief @brief Sets the drag step increment.
   ///
   /// Sets the x,y step increments for a dragable object.
   ///
   /// Values for @p dx and @p dy are real numbers that range from 0 to 1,
   /// representing the relative size of the dragable area on that axis by which the
   /// part will be moved.
   ///
   /// @see edje_object_part_drag_step_get()
   ///
   /// @param part The part name
   /// @param dx The x step amount
   /// @param dy The y step amount
   ///
   bool part_drag_step_set(std::string part_, double dx_, double dy_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_step_set(efl::eolian::to_c(part_), dx_, dy_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Gets the drag step increment values.
   ///
   /// Gets the x and y step increments for the dragable object.
   ///
   ///
   /// @see edje_object_part_drag_step_set()
   ///
   /// @param part The part
   /// @param[out] dx The x step increment pointer
   /// @param[out] dy The y step increment pointer
   ///
   bool part_drag_step_get(std::string part_, double* dx_, double* dy_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_step_get(efl::eolian::to_c(part_), dx_, dy_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Get the input method context in entry.
   ///
   /// If ecore_imf was not available when edje was compiled, this function returns NULL
   /// otherwise, the returned pointer is an Ecore_IMF
   ///
   /// @return The input method context (Ecore_IMF_Context *) in entry
   /// @since 1.2.0
   ///
   /// @param part The part name
   ///
   void * part_text_imf_context_get(std::string part_) const
   {
      void * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_imf_context_get(efl::eolian::to_c(part_)));
      return _tmp_ret;
   }

   /// @brief @brief Starts selecting at current cursor position
   ///
   /// @param part The part name
   ///
   void part_text_select_begin(std::string part_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_select_begin(efl::eolian::to_c(part_)));
   }

   /// @brief @brief Return the text of the object part.
   ///
   /// @return The text string
   ///
   /// This function returns the style associated with the textblock part.
   ///
   /// @since 1.2.0
   ///
   /// @param part The part name
   ///
   std::string part_text_style_user_peek(std::string part_) const
   {
      const char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_style_user_peek(efl::eolian::to_c(part_)));
      return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Remove a signal-triggered callback from an object.
   ///
   /// @return The data pointer
   ///
   /// This function removes a callback, previously attached to the
   /// emittion of a signal, from the object @a obj. The parameters @a
   /// emission, @a source and @a func must match exactly those passed to
   /// a previous call to edje_object_signal_callback_add(). The data
   /// pointer that was passed to this call will be returned.
   ///
   /// @see edje_object_signal_callback_add().
   /// @see edje_object_signal_callback_del_full().
   ///
   /// @param emission The emission string.
   /// @param source The source string.
   /// @param func The callback function.
   /// @param data The callback function.
   ///
   void * signal_callback_del(std::string emission_, std::string source_, Edje_Signal_Cb func_, void * data_) const
   {
      void * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_signal_callback_del(efl::eolian::to_c(emission_), efl::eolian::to_c(source_), func_, data_));
      return _tmp_ret;
   }

   /// @brief @brief Advances the cursor to the next cursor position.
   /// @see evas_textblock_cursor_char_next
   ///
   /// @param part The part name
   /// @param cur The edje cursor to advance
   ///
   bool part_text_cursor_next(std::string part_, Edje_Cursor cur_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_next(efl::eolian::to_c(part_), cur_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Set the style of the
   ///
   /// This function sets the style associated with the textblock part.
   ///
   /// @since 1.2.0
   ///
   /// @param part The part name
   /// @param style The style to set (textblock conventions).
   ///
   void part_text_style_user_push(std::string part_, std::string style_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_style_user_push(efl::eolian::to_c(part_), efl::eolian::to_c(style_)));
   }

   /// @brief @brief Insert text for an object part.
   ///
   /// This function inserts the text for an object part at the end; It does not
   /// move the cursor.
   ///
   /// @since 1.1
   ///
   /// @param part The part name
   /// @param text The text string
   ///
   void part_text_append(std::string part_, std::string text_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_append(efl::eolian::to_c(part_), efl::eolian::to_c(text_)));
   }

   /// @brief @brief Retrieve the geometry of a given Edje part, in a given Edje
   /// object's group definition, <b>relative to the object's area</b>
   ///
   /// This function gets the geometry of an Edje part within its
   /// group. The @p x and @p y coordinates are relative to the top left
   /// corner of the whole @p obj object's area.
   ///
   /// @note Use @c NULL pointers on the geometry components you're not
   /// interested in: they'll be ignored by the function.
   ///
   /// @note On failure, this function will make all non-@c NULL geometry
   /// pointers' pointed variables be set to zero.
   ///
   /// @param part The Edje part's name
   /// @param[out] x A pointer to a variable where to store the part's x
   /// coordinate
   /// @param[out] y A pointer to a variable where to store the part's y
   /// coordinate
   /// @param[out] w A pointer to a variable where to store the part's width
   /// @param[out] h A pointer to a variable where to store the part's height
   ///
   bool part_geometry_get(std::string part_, Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_geometry_get(efl::eolian::to_c(part_), x_, y_, w_, h_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Hide the input panel (virtual keyboard).
   /// @see edje_object_part_text_input_panel_show
   ///
   /// Note that input panel is shown or hidden automatically according to the focus state.
   /// This API can be used in the case of manually controlling by using edje_object_part_text_input_panel_enabled_set.
   ///
   /// @since 1.2.0
   ///
   /// @param part The part name
   ///
   void part_text_input_panel_hide(std::string part_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_input_panel_hide(efl::eolian::to_c(part_)));
   }

   /// @brief @brief Return item geometry.
   ///
   /// @return 1 if item exists, 0 if not
   ///
   /// This function return a list of Evas_Textblock_Rectangle item
   /// rectangles.
   ///
   /// @param part The part name
   /// @param item The item name
   /// @param[out] cx Item x return (relative to entry part)
   /// @param[out] cy Item y return (relative to entry part)
   /// @param[out] cw Item width return
   /// @param[out] ch Item height return
   ///
   bool part_text_item_geometry_get(std::string part_, std::string item_, Evas_Coord* cx_, Evas_Coord* cy_, Evas_Coord* cw_, Evas_Coord* ch_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_item_geometry_get(efl::eolian::to_c(part_), efl::eolian::to_c(item_), cx_, cy_, cw_, ch_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Removes an object from the table.
   ///
   /// @return @c EINA_TRUE object removed, @c EINA_FALSE on failure
   ///
   /// Removes an object from the table indicated by part.
   ///
   /// @param part The part name
   /// @param child_obj The object to pack in
   ///
   bool part_table_unpack(std::string part_, evas::object child_obj_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_table_unpack(efl::eolian::to_c(part_), efl::eolian::to_c(child_obj_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Aborts any selection action on a part.
   ///
   /// @param part The part name
   ///
   void part_text_select_abort(std::string part_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_select_abort(efl::eolian::to_c(part_)));
   }

   /// @brief Delete a function and matching user data from the filter list.
   ///
   /// Delete the given @p func filter and @p data user data from the list
   /// in @p part.
   /// Returns the user data pointer given when added.
   ///
   /// @see edje_object_text_insert_filter_callback_add
   /// @see edje_object_text_insert_filter_callback_del
   ///
   /// @return The same data pointer if successful, or NULL otherwise
   ///
   /// @param part The part name
   /// @param func The function callback to remove
   /// @param data The data passed to the callback function
   ///
   void * text_insert_filter_callback_del_full(std::string part_, Edje_Text_Filter_Cb func_, void * data_) const
   {
      void * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_text_insert_filter_callback_del_full(efl::eolian::to_c(part_), func_, data_));
      return _tmp_ret;
   }

   /// @brief @brief Delete the top style form the user style stack.
   ///
   /// @since 1.2.0
   ///
   /// @param part The part name
   ///
   void part_text_style_user_pop(std::string part_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_style_user_pop(efl::eolian::to_c(part_)));
   }

   /// @brief Set the input panel-specific data to deliver to the input panel.
   ///
   /// This API is used by applications to deliver specific data to the input panel.
   /// The data format MUST be negotiated by both application and the input panel.
   /// The size and format of data are defined by the input panel.
   ///
   /// @since 1.2.0
   ///
   /// @param part The part name
   /// @param data The specific data to be set to the input panel.
   /// @param len the length of data, in bytes, to send to the input panel
   ///
   void part_text_input_panel_imdata_set(std::string part_, const void * data_, int len_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_input_panel_imdata_set(efl::eolian::to_c(part_), data_, len_));
   }

   /// @brief Get the specific data of the current active input panel.
   ///
   /// @since 1.2.0
   ///
   /// @param part The part name
   /// @param data The specific data to be got from the input panel
   /// @param len The length of data
   ///
   void part_text_input_panel_imdata_get(std::string part_, void * data_, int * len_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_input_panel_imdata_get(efl::eolian::to_c(part_), data_, len_));
   }

   /// @brief @brief Insert text for an object part.
   ///
   /// This function inserts the text for an object part just before the
   /// cursor position.
   ///
   /// @param part The part name
   /// @param text The text string
   ///
   void part_text_insert(std::string part_, std::string text_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_insert(efl::eolian::to_c(part_), efl::eolian::to_c(text_)));
   }

   /// @brief @brief Removes an object from the box.
   ///
   /// @return Pointer to the object removed, or @c NULL.
   ///
   /// Removes from the box indicated by part, the object in the position
   /// pos.
   ///
   /// @see edje_object_part_box_remove()
   /// @see edje_object_part_box_remove_all()
   ///
   /// @param part The part name
   /// @param pos The position index of the object (starts counting from 0)
   ///
   evas::object part_box_remove_at(std::string part_, unsigned int pos_) const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_box_remove_at(efl::eolian::to_c(part_), pos_));
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Copy the cursor to another cursor.
   ///
   /// @param part The part name
   /// @param src the cursor to copy from
   /// @param dst the cursor to copy to
   ///
   void part_text_cursor_copy(std::string part_, Edje_Cursor src_, Edje_Cursor dst_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_cursor_copy(efl::eolian::to_c(part_), src_, dst_));
   }

   /// @brief Calculate the geometry of the region, relative to a given Edje
   /// object's area, <b>occupied by all parts in the object</b>
   ///
   /// This function gets the geometry of the rectangle equal to the area
   /// required to group all parts in @p obj's group/collection. The @p x
   /// and @p y coordinates are relative to the top left corner of the
   /// whole @p obj object's area. Parts placed out of the group's
   /// boundaries will also be taken in account, so that @p x and @p y
   /// <b>may be negative</b>.
   ///
   /// @note Use @c NULL pointers on the geometry components you're not
   /// interested in: they'll be ignored by the function.
   ///
   /// @note On failure, this function will make all non-@c NULL geometry
   /// pointers' pointed variables be set to zero.
   ///
   /// @param[out] x A pointer to a variable where to store the parts region's
   /// x coordinate
   /// @param[out] y A pointer to a variable where to store the parts region's
   /// y coordinate
   /// @param[out] w A pointer to a variable where to store the parts region's
   /// width
   /// @param[out] h A pointer to a variable where to store the parts region's
   /// height
   ///
   bool parts_extends_calc(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_parts_extends_calc(x_, y_, w_, h_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Set the dragable object location.
   ///
   /// Places the dragable object at the given location.
   ///
   /// Values for @p dx and @p dy are real numbers that range from 0 to 1,
   /// representing the relative position to the dragable area on that axis.
   ///
   /// This value means, for the vertical axis, that 0.0 will be at the top if the
   /// first parameter of @c y in the dragable part theme is 1, and at bottom if it
   /// is -1.
   ///
   /// For the horizontal axis, 0.0 means left if the first parameter of @c x in the
   /// dragable part theme is 1, and right if it is -1.
   ///
   /// @see edje_object_part_drag_value_get()
   ///
   /// @param part The part name
   /// @param dx The x value
   /// @param dy The y value
   ///
   bool part_drag_value_set(std::string part_, double dx_, double dy_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_value_set(efl::eolian::to_c(part_), dx_, dy_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Get the dragable object location.
   ///
   /// Values for @p dx and @p dy are real numbers that range from 0 to 1,
   /// representing the relative position to the dragable area on that axis.
   ///
   /// @see edje_object_part_drag_value_set()
   ///
   /// Gets the drag location values.
   ///
   /// @param part The part name
   /// @param[out] dx The X value pointer
   /// @param[out] dy The Y value pointer
   ///
   bool part_drag_value_get(std::string part_, double* dx_, double* dy_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_value_get(efl::eolian::to_c(part_), dx_, dy_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Force a Size/Geometry calculation.
   ///
   /// Forces the object @p obj to recalculation layout regardless of
   /// freeze/thaw.
   ///
   void calc_force() const
   {
      eo_do(_eo_ptr(), ::edje_obj_calc_force());
   }

   /// @brief @brief Sets the cursor position to the given value
   ///
   /// @since 1.1.0
   ///
   /// @param part The part name
   /// @param cur The cursor to move
   /// @param pos the position of the cursor
   ///
   void part_text_cursor_pos_set(std::string part_, Edje_Cursor cur_, int pos_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_cursor_pos_set(efl::eolian::to_c(part_), cur_, pos_));
   }

   /// @brief @brief Retrieves the current position of the cursor
   ///
   /// @return The cursor position
   /// @since 1.1.0
   ///
   /// @param part The part name
   /// @param cur The cursor to get the position
   ///
   int part_text_cursor_pos_get(std::string part_, Edje_Cursor cur_) const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_pos_get(efl::eolian::to_c(part_), cur_));
      return _tmp_ret;
   }

   /// @brief @brief Freezes the Edje object.
   ///
   /// @return The frozen state or 0 on Error
   ///
   /// This function puts all changes on hold. Successive freezes will
   /// nest, requiring an equal number of thaws.
   ///
   /// @see edje_object_thaw()
   ///
   int freeze() const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_freeze());
      return _tmp_ret;
   }

   /// @brief @brief Returns the content (char) at the cursor position.
   /// @see evas_textblock_cursor_content_get
   ///
   /// You must free the return (if not NULL) after you are done with it.
   ///
   /// @return The character string pointed to (may be a multi-byte utf8 sequence) terminated by a nul byte.
   ///
   /// @param part The part name
   /// @param cur The cursor to use
   ///
   char * part_text_cursor_content_get(std::string part_, Edje_Cursor cur_) const
   {
      char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_content_get(efl::eolian::to_c(part_), cur_));
      return _tmp_ret;
   }

   /// @brief @brief Set the layout of the input panel.
   ///
   /// The layout of the input panel or virtual keyboard can make it easier or
   /// harder to enter content. This allows you to hint what kind of input you
   /// are expecting to enter and thus have the input panel automatically
   /// come up with the right mode.
   ///
   /// @since 1.1
   ///
   /// @param part The part name
   /// @param layout layout type
   ///
   void part_text_input_panel_layout_set(std::string part_, Edje_Input_Panel_Layout layout_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_input_panel_layout_set(efl::eolian::to_c(part_), layout_));
   }

   /// @brief @brief Get the layout of the input panel.
   ///
   /// @return Layout type of the input panel
   ///
   /// @see edje_object_part_text_input_panel_layout_set
   /// @since 1.1
   ///
   /// @param part The part name
   ///
   Edje_Input_Panel_Layout part_text_input_panel_layout_get(std::string part_) const
   {
      Edje_Input_Panel_Layout _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_panel_layout_get(efl::eolian::to_c(part_)));
      return _tmp_ret;
   }

   /// @brief @brief Packs an object into the table.
   ///
   /// @return @c EINA_TRUE object was added, @c EINA_FALSE on failure
   ///
   /// Packs an object into the table indicated by part.
   ///
   /// @param part The part name
   /// @param child_obj The object to pack in
   /// @param col The column to place it in
   /// @param row The row to place it in
   /// @param colspan Columns the child will take
   /// @param rowspan Rows the child will take
   ///
   bool part_table_pack(std::string part_, evas::object child_obj_, unsigned short col_, unsigned short row_, unsigned short colspan_, unsigned short rowspan_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_table_pack(efl::eolian::to_c(part_), efl::eolian::to_c(child_obj_), col_, row_, colspan_, rowspan_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Set the language mode of the input panel.
   ///
   /// This API can be used if you want to show the Alphabet keyboard.
   ///
   /// @since 1.2.0
   ///
   /// @param part The part name
   /// @param lang the language to be set to the input panel.
   ///
   void part_text_input_panel_language_set(std::string part_, Edje_Input_Panel_Lang lang_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_input_panel_language_set(efl::eolian::to_c(part_), lang_));
   }

   /// @brief Get the language mode of the input panel.
   ///
   /// See @ref edje_object_part_text_input_panel_language_set for more details.
   ///
   /// @return input panel language type
   /// @since 1.2.0
   ///
   /// @param part The part name
   ///
   Edje_Input_Panel_Lang part_text_input_panel_language_get(std::string part_) const
   {
      Edje_Input_Panel_Lang _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_panel_language_get(efl::eolian::to_c(part_)));
      return _tmp_ret;
   }

   /// @brief @brief Gets the number of columns and rows the table has.
   ///
   /// @return @c EINA_TRUE get some data, @c EINA_FALSE on failure
   ///
   /// Retrieves the size of the table in number of columns and rows.
   ///
   /// @param part The part name
   /// @param[out] cols Pointer where to store number of columns (can be NULL)
   /// @param[out] rows Pointer where to store number of rows (can be NULL)
   ///
   bool part_table_col_row_size_get(std::string part_, int* cols_, int* rows_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_table_col_row_size_get(efl::eolian::to_c(part_), cols_, rows_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Get the object created by this external part.
   ///
   /// Parts of type external creates the part object using information
   /// provided by external plugins. It's somehow like "swallow"
   /// (edje_object_part_swallow()), but it's all set automatically.
   ///
   /// This function returns the part created by such external plugins and
   /// being currently managed by this Edje.
   ///
   /// @note Almost all swallow rules apply: you should not move, resize,
   /// hide, show, set the color or clipper of such part. It's a bit
   /// more restrictive as one must @b never delete this object!
   ///
   /// @return The externally created object, or NULL if there is none or
   /// part is not an external.
   ///
   /// @param part The part name
   ///
   evas::object part_external_object_get(std::string part_) const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_external_object_get(efl::eolian::to_c(part_)));
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Get an object contained in an part of type EXTERNAL
   ///
   /// The @p content string must not be NULL. Its actual value depends on the
   /// code providing the EXTERNAL.
   ///
   /// @param part The name of the part holding the EXTERNAL
   /// @param[out] content A string identifying which content from the EXTERNAL to get
   ///
   evas::object part_external_content_get(std::string part_, const char* content_) const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_external_content_get(efl::eolian::to_c(part_), content_));
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Preload the images on the Edje Object in the background.
   ///
   /// @return @c EINA_FASLE if obj was not a valid Edje object
   /// otherwise @c EINA_TRUE
   ///
   /// This function requests the preload of all data images (on the given
   /// object) in the background. The work is queued before being processed
   /// (because there might be other pending requests of this type).
   /// It emits a signal "preload,done" when finished.
   ///
   /// @note Use @c EINA_TRUE on scenarios where you don't need
   /// the image data preloaded anymore.
   ///
   /// @param cancel @c EINA_FALSE will add it the preloading work queue,
   /// @c EINA_TRUE will remove it (if it was issued before).
   ///
   bool preload(bool cancel_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_preload(efl::eolian::to_c(cancel_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Sets the attribute to show the input panel automatically.
   ///
   /// @since 1.1.0
   ///
   /// @param part The part name
   /// @param enabled If true, the input panel is appeared when entry is clicked or has a focus
   ///
   void part_text_input_panel_enabled_set(std::string part_, bool enabled_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_input_panel_enabled_set(efl::eolian::to_c(part_), efl::eolian::to_c(enabled_)));
   }

   /// @brief @brief Retrieve the attribute to show the input panel automatically.
   /// @see edje_object_part_text_input_panel_enabled_set
   ///
   /// @return EINA_TRUE if it supports or EINA_FALSE otherwise
   /// @since 1.1.0
   ///
   /// @param part The part name
   ///
   bool part_text_input_panel_enabled_get(std::string part_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_panel_enabled_get(efl::eolian::to_c(part_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Extends the current selection to the current cursor position
   ///
   /// @param part The part name
   ///
   void part_text_select_extend(std::string part_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_select_extend(efl::eolian::to_c(part_)));
   }

   /// @brief @brief Inserts an object to the box.
   ///
   /// @return @c EINA_TRUE: Successfully added.\n
   /// @c EINA_FALSE: An error occurred.
   ///
   /// Adds child to the box indicated by part, in the position given by
   /// pos.
   ///
   /// @see edje_object_part_box_append()
   /// @see edje_object_part_box_prepend()
   /// @see edje_object_part_box_insert_before()
   ///
   /// @param part The part name
   /// @param child The object to insert
   /// @param pos The position where to insert child
   ///
   bool part_box_insert_at(std::string part_, evas::object child_, unsigned int pos_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_box_insert_at(efl::eolian::to_c(part_), efl::eolian::to_c(child_), pos_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Return a list of Evas_Textblock_Rectangle anchor rectangles.
   ///
   /// @return The list of anchor rects (const Evas_Textblock_Rectangle
   /// *), do not modify! Geometry is relative to entry part.
   ///
   /// This function return a list of Evas_Textblock_Rectangle anchor
   /// rectangles.
   ///
   /// @param part The part name
   /// @param anchor The anchor name
   ///
   efl::eina::crange_list< const Evas_Textblock_Rectangle * > part_text_anchor_geometry_get(std::string part_, std::string anchor_) const
   {
      const Eina_List * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_anchor_geometry_get(efl::eolian::to_c(part_), efl::eolian::to_c(anchor_)));
      return efl::eolian::to_cxx<efl::eina::crange_list< const Evas_Textblock_Rectangle * >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
   }

   /// @brief @brief Moves the cursor to the char below the current cursor position.
   ///
   /// @param part The part name
   /// @param cur the edje cursor to work on
   ///
   bool part_text_cursor_down(std::string part_, Edje_Cursor cur_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_down(efl::eolian::to_c(part_), cur_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Sets the page step increments.
   ///
   /// Sets the x,y page step increment values.
   ///
   /// Values for @p dx and @p dy are real numbers that range from 0 to 1,
   /// representing the relative size of the dragable area on that axis by which the
   /// part will be moved.
   ///
   /// @see edje_object_part_drag_page_get()
   ///
   /// @param part The part name
   /// @param dx The x page step increment
   /// @param dy The y page step increment
   ///
   bool part_drag_page_set(std::string part_, double dx_, double dy_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_page_set(efl::eolian::to_c(part_), dx_, dy_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Gets the page step increments.
   ///
   /// Gets the x,y page step increments for the dragable object.
   ///
   /// @see edje_object_part_drag_page_set()
   ///
   /// @param part The part name
   /// @param[out] dx The dx page increment pointer
   /// @param[out] dy The dy page increment pointer
   ///
   bool part_drag_page_get(std::string part_, double* dx_, double* dy_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_page_get(efl::eolian::to_c(part_), dx_, dy_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Prepends an object to the box.
   ///
   /// @return @c EINA_TRUE: Successfully added.\n
   /// @c EINA_FALSE: An error occurred.
   ///
   /// Prepends child to the box indicated by part.
   ///
   /// @see edje_object_part_box_append()
   /// @see edje_object_part_box_insert_before()
   /// @see edje_object_part_box_insert_at()
   ///
   /// @param part The part name
   /// @param child The object to prepend
   ///
   bool part_box_prepend(std::string part_, evas::object child_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_box_prepend(efl::eolian::to_c(part_), efl::eolian::to_c(child_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Send/emit an Edje signal to a given Edje object
   ///
   /// This function sends a signal to the object @a obj. An Edje program,
   /// at @p obj's EDC specification level, can respond to a signal by
   /// having declared matching @c 'signal' and @c 'source' fields on its
   /// block (see @ref edcref "the syntax" for EDC files).
   ///
   /// As an example,
   /// @code
   /// edje_object_signal_emit(obj, "a_signal", "");
   /// @endcode
   /// would trigger a program which had an EDC declaration block like
   /// @code
   /// program {
   /// name: "a_program";
   /// signal: "a_signal";
   /// source: "";
   /// action: ...
   /// }
   /// @endcode
   ///
   /// @see edje_object_signal_callback_add() for more on Edje signals.
   ///
   /// @param emission The signal's "emission" string
   /// @param source The signal's "source" string
   ///
   void signal_emit(std::string emission_, std::string source_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_signal_emit(efl::eolian::to_c(emission_), efl::eolian::to_c(source_)));
   }

   /// @brief @brief Set the layout variation of the input panel.
   ///
   /// The layout variation of the input panel or virtual keyboard can make it easier or
   /// harder to enter content. This allows you to hint what kind of input you
   /// are expecting to enter and thus have the input panel automatically
   /// come up with the right mode.
   ///
   /// @since 1.8
   ///
   /// @param part The part name
   /// @param variation layout variation type
   ///
   void part_text_input_panel_layout_variation_set(std::string part_, int variation_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_input_panel_layout_variation_set(efl::eolian::to_c(part_), variation_));
   }

   /// @brief @brief Get the layout variation of the input panel.
   ///
   /// @return Layout variation type of the input panel
   ///
   /// @see edje_object_part_text_input_panel_layout_variation_set
   /// @since 1.8
   ///
   /// @param part The part name
   ///
   int part_text_input_panel_layout_variation_get(std::string part_) const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_panel_layout_variation_get(efl::eolian::to_c(part_)));
      return _tmp_ret;
   }

   /// @brief @brief Send an (Edje) message to a given Edje object
   ///
   /// This function sends an Edje message to @p obj and to all of its
   /// child objects, if it has any (swallowed objects are one kind of
   /// child object). @p type and @p msg @b must be matched accordingly,
   /// as documented in #Edje_Message_Type.
   ///
   /// The @p id argument as a form of code and theme defining a common
   /// interface on message communication. One should define the same IDs
   /// on both code and EDC declaration (see @ref edcref "the syntax" for
   /// EDC files), to individualize messages (binding them to a given
   /// context).
   ///
   /// The function to handle messages arriving @b from @b obj is set with
   /// edje_object_message_handler_set().
   ///
   /// @param type The type of message to send to @p obj
   /// @param id A identification number for the message to be sent
   /// @param msg The message's body, a struct depending on @p type
   ///
   void message_send(Edje_Message_Type type_, int id_, void * msg_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_message_send(type_, id_, msg_));
   }

   /// @brief @brief Set the selection to be none.
   ///
   /// This function sets the selection text to be none.
   ///
   /// @param part The part name
   ///
   void part_text_select_none(std::string part_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_select_none(efl::eolian::to_c(part_)));
   }

   /// @brief @brief Get a handle to the Evas object implementing a given Edje
   /// part, in an Edje object.
   ///
   /// @return A pointer to the Evas object implementing the given part,
   /// or @c NULL on failure (e.g. the given part doesn't exist)
   ///
   /// This function gets a pointer of the Evas object corresponding to a
   /// given part in the @p obj object's group.
   ///
   /// You should @b never modify the state of the returned object (with
   /// @c evas_object_move() or @c evas_object_hide() for example),
   /// because it's meant to be managed by Edje, solely. You are safe to
   /// query information about its current state (with @c
   /// evas_object_visible_get() or @c evas_object_color_get() for
   /// example), though.
   ///
   /// @param part The Edje part's name
   ///
   const Evas_Object * part_object_get(std::string part_) const
   {
      const Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_object_get(efl::eolian::to_c(part_)));
      return _tmp_ret;
   }

   /// @brief @brief Set the dragable object size.
   ///
   /// Values for @p dw and @p dh are real numbers that range from 0 to 1,
   /// representing the relative size of the dragable area on that axis.
   ///
   /// Sets the size of the dragable object.
   ///
   /// @see edje_object_part_drag_size_get()
   ///
   /// @param part The part name
   /// @param dw The drag width
   /// @param dh The drag height
   ///
   bool part_drag_size_set(std::string part_, double dw_, double dh_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_size_set(efl::eolian::to_c(part_), dw_, dh_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Get the dragable object size.
   ///
   /// Gets the dragable object size.
   ///
   /// @see edje_object_part_drag_size_set()
   ///
   /// @param part The part name
   /// @param[out] dw The drag width pointer
   /// @param[out] dh The drag height pointer
   ///
   bool part_drag_size_get(std::string part_, double* dw_, double* dh_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_size_get(efl::eolian::to_c(part_), dw_, dh_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Delete a function from the filter list.
   ///
   /// Delete the given @p func filter from the list in @p part. Returns
   /// the user data pointer given when added.
   ///
   /// @see edje_object_text_insert_filter_callback_add
   /// @see edje_object_text_insert_filter_callback_del_full
   ///
   /// @return The user data pointer if successful, or NULL otherwise
   ///
   /// @param part The part name
   /// @param func The function callback to remove
   ///
   void * text_insert_filter_callback_del(std::string part_, Edje_Text_Filter_Cb func_) const
   {
      void * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_text_insert_filter_callback_del(efl::eolian::to_c(part_), func_));
      return _tmp_ret;
   }

   /// @brief @brief Determine dragable directions.
   ///
   /// The dragable directions are defined in the EDC file, inside the @c dragable
   /// section, by the attributes @c x and @c y. See the @ref edcref for more
   /// information.
   ///
   /// @return #EDJE_DRAG_DIR_NONE: Not dragable\n
   /// #EDJE_DRAG_DIR_X: Dragable in X direction\n
   /// #EDJE_DRAG_DIR_Y: Dragable in Y direction\n
   /// #EDJE_DRAG_DIR_XY: Dragable in X & Y directions
   ///
   /// @param part The part name
   ///
   Edje_Drag_Dir part_drag_dir_get(std::string part_) const
   {
      Edje_Drag_Dir _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_dir_get(efl::eolian::to_c(part_)));
      return _tmp_ret;
   }

   /// @brief @brief Sets the raw (non escaped) text for an object part.
   ///
   /// This funciton will not do escape for you if it is a TEXTBLOCK part, that is,
   /// if text contain tags, these tags will not be interpreted/parsed by TEXTBLOCK.
   ///
   /// @see edje_object_part_text_unescaped_get().
   ///
   /// @param part The part name
   /// @param text_to_escape The text string
   ///
   bool part_text_unescaped_set(std::string part_, std::string text_to_escape_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_unescaped_set(efl::eolian::to_c(part_), efl::eolian::to_c(text_to_escape_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Returns the text of the object part, without escaping.
   ///
   /// @return The @b allocated text string without escaping, or NULL on
   /// problems.
   ///
   /// This function is the counterpart of
   /// edje_object_part_text_unescaped_set(). Please notice that the
   /// result is newly allocated memory and should be released with free()
   /// when done.
   ///
   /// @see edje_object_part_text_unescaped_set().
   ///
   /// @param part The part name
   ///
   char * part_text_unescaped_get(std::string part_) const
   {
      char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_unescaped_get(efl::eolian::to_c(part_)));
      return _tmp_ret;
   }

   /// @brief @brief Add a callback for an arriving Edje signal, emitted by
   /// a given Edje object.
   ///
   /// Edje signals are one of the communication interfaces between
   /// @b code and a given Edje object's @b theme. With signals, one can
   /// communicate two string values at a time, which are:
   /// - "emission" value: the name of the signal, in general
   /// - "source" value: a name for the signal's context, in general
   ///
   /// Though there are those common uses for the two strings, one is free
   /// to use them however they like.
   ///
   /// This function adds a callback function to a signal emitted by @a obj, to
   /// be issued every time an EDC program like the following
   /// @code
   /// program {
   /// name: "emit_example";
   /// action: SIGNAL_EMIT "a_signal" "a_source";
   /// }
   /// @endcode
   /// is run, if @p emission and @p source are given those same values,
   /// here.
   ///
   /// Signal callback registration is powerful, in the way that @b blobs
   /// may be used to match <b>multiple signals at once</b>. All the @c
   /// "*?[\" set of @c fnmatch() operators can be used, both for @p
   /// emission and @p source.
   ///
   /// Edje has @b internal signals it will emit, automatically, on
   /// various actions taking place on group parts. For example, the mouse
   /// cursor being moved, pressed, released, etc., over a given part's
   /// area, all generate individual signals.
   ///
   /// By using something like
   /// @code
   /// edje_object_signal_callback_add(obj, "mouse,down,*", "button.*",
   /// signal_cb, NULL);
   /// @endcode
   /// being @c "button.*" the pattern for the names of parts implementing
   /// buttons on an interface, you'd be registering for notifications on
   /// events of mouse buttons being pressed down on either of those parts
   /// (those events all have the @c "mouse,down," common prefix on their
   /// names, with a suffix giving the button number). The actual emission
   /// and source strings of an event will be passed in as the @a emission
   /// and @a source parameters of the callback function (e.g. @c
   /// "mouse,down,2" and @c "button.close"), for each of those events.
   ///
   /// @note See @ref edcref "the syntax" for EDC files
   /// @see edje_object_signal_emit() on how to emits Edje signals from
   /// code to a an object
   /// @see edje_object_signal_callback_del_full()
   ///
   /// @param emission The signal's "emission" string
   /// @param source The signal's "source" string
   /// @param func The callback function to be executed when the signal is
   /// emitted.
   /// @param data A pointer to data to pass in to @p func.
   ///
   void signal_callback_add(std::string emission_, std::string source_, Edje_Signal_Cb func_, void * data_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_signal_callback_add(efl::eolian::to_c(emission_), efl::eolian::to_c(source_), func_, data_));
   }

   /// @brief @brief Set the selection to be everything.
   ///
   /// This function selects all text of the object of the part.
   ///
   /// @param part The part name
   ///
   void part_text_select_all(std::string part_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_select_all(efl::eolian::to_c(part_)));
   }

   /// @brief Set the return key on the input panel to be disabled.
   ///
   /// @since 1.2.0
   ///
   /// @param part The part name
   /// @param disabled The state
   ///
   void part_text_input_panel_return_key_disabled_set(std::string part_, bool disabled_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_input_panel_return_key_disabled_set(efl::eolian::to_c(part_), efl::eolian::to_c(disabled_)));
   }

   /// @brief Get whether the return key on the input panel should be disabled or not.
   ///
   /// @return EINA_TRUE if it should be disabled
   /// @since 1.2.0
   ///
   /// @param part The part name
   ///
   bool part_text_input_panel_return_key_disabled_get(std::string part_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_panel_return_key_disabled_get(efl::eolian::to_c(part_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Set the autocapitalization type on the immodule.
   ///
   /// @since 1.1.0
   ///
   /// @param part The part name
   /// @param autocapital_type The type of autocapitalization
   ///
   void part_text_autocapital_type_set(std::string part_, Edje_Text_Autocapital_Type autocapital_type_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_autocapital_type_set(efl::eolian::to_c(part_), autocapital_type_));
   }

   /// @brief @brief Retrieves the autocapitalization type
   ///
   /// @return The autocapitalization type
   /// @since 1.1.0
   ///
   /// @param part The part name
   ///
   Edje_Text_Autocapital_Type part_text_autocapital_type_get(std::string part_) const
   {
      Edje_Text_Autocapital_Type _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_autocapital_type_get(efl::eolian::to_c(part_)));
      return _tmp_ret;
   }

   /// @brief @brief Unswallow an object.
   ///
   /// Causes the edje to regurgitate a previously swallowed object. :)
   ///
   /// @note @p obj_swallow will @b not be deleted or hidden.
   /// @note @p obj_swallow may appear shown on the evas depending on its state when
   /// it got unswallowed. Make sure you delete it or hide it if you do not want it to.
   ///
   /// @param obj_swallow The swallowed object
   ///
   void part_unswallow(evas::object obj_swallow_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_unswallow(efl::eolian::to_c(obj_swallow_)));
   }

   /// @brief @brief Set whether the prediction is allowed or not.
   ///
   /// @since 1.2.0
   ///
   /// @param part The part name
   /// @param prediction If true, the prediction feature is allowed.
   ///
   void part_text_prediction_allow_set(std::string part_, bool prediction_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_prediction_allow_set(efl::eolian::to_c(part_), efl::eolian::to_c(prediction_)));
   }

   /// @brief @brief Get whether the prediction is allowed or not.
   ///
   /// @return EINA_TRUE if prediction feature is allowed.
   /// @since 1.2.0
   ///
   /// @param part The part name
   ///
   bool part_text_prediction_allow_get(std::string part_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_prediction_allow_get(efl::eolian::to_c(part_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Retrive an <b>EDC data field's value</b> from a given Edje
   /// object's group.
   ///
   /// @return The data's value string. Must not be freed.
   ///
   /// This function fetches an EDC data field's value, which is declared
   /// on the objects building EDC file, <b>under its group</b>. EDC data
   /// blocks are most commonly used to pass arbitrary parameters from an
   /// application's theme to its code.
   ///
   /// They look like the following:
   ///
   /// @code
   /// collections {
   /// group {
   /// name: "a_group";
   /// data {
   /// item: "key1" "value1";
   /// item: "key2" "value2";
   /// }
   /// }
   /// }
   /// @endcode
   ///
   /// EDC data fields always hold @b strings as values, hence the return
   /// type of this function. Check the complete @ref edcref "syntax reference"
   /// for EDC files.
   ///
   /// @warning Do not confuse this call with edje_file_data_get(), which
   /// queries for a @b global EDC data field on an EDC declaration file.
   ///
   /// @see edje_object_file_set()
   ///
   /// @param key The data field's key string
   ///
   std::string data_get(std::string key_) const
   {
      const char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_data_get(efl::eolian::to_c(key_)));
      return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Add a markup filter function for newly inserted text.
   ///
   /// Whenever text is inserted (not the same as set) into the given @p part,
   /// the list of markup filter functions will be called to decide if and how
   /// the new text will be accepted.
   /// The text parameter in the @p func filter is always markup. It can be
   /// modified by the user and it's up to him to free the one passed if he's to
   /// change the pointer. If doing so, the newly set text should be malloc'ed,
   /// as once all the filters are called Edje will free it.
   /// If the text is to be rejected, freeing it and setting the pointer to NULL
   /// will make Edje break out of the filter cycle and reject the inserted
   /// text.
   /// This function is different from edje_object_text_insert_filter_callback_add()
   /// in that the text parameter in the @p fucn filter is always markup.
   ///
   /// @warning If you use this function with
   /// edje_object_text_insert_filter_callback_add() togehter, all
   /// Edje_Text_Filter_Cb functions and Edje_Markup_Filter_Cb functions
   /// will be executed, and then filtered text will be inserted.
   ///
   /// @see edje_object_text_markup_filter_callback_del
   /// @see edje_object_text_markup_filter_callback_del_full
   /// @see edje_object_text_insert_filter_callback_add
   ///
   /// @since 1.2.0
   ///
   /// @param part The part name
   /// @param func The callback function that will act as markup filter
   /// @param data User provided data to pass to the filter function
   ///
   void text_markup_filter_callback_add(std::string part_, Edje_Markup_Filter_Cb func_, void * data_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_text_markup_filter_callback_add(efl::eolian::to_c(part_), func_, data_));
   }

   /// @brief @brief Process an object's message queue.
   ///
   /// This function goes through the object message queue processing the
   /// pending messages for @b this specific Edje object. Normally they'd
   /// be processed only at idle time.
   ///
   void message_signal_process() const
   {
      eo_do(_eo_ptr(), ::edje_obj_message_signal_process());
   }

   /// @brief @brief Removes an object from the box.
   ///
   /// @return Pointer to the object removed, or @c NULL.
   ///
   /// Removes child from the box indicated by part.
   ///
   /// @see edje_object_part_box_remove_at()
   /// @see edje_object_part_box_remove_all()
   ///
   /// @param part The part name
   /// @param child The object to remove
   ///
   evas::object part_box_remove(std::string part_, evas::object child_) const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_box_remove(efl::eolian::to_c(part_), efl::eolian::to_c(child_)));
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Thaws the Edje object.
   ///
   /// @return The frozen state or 0 if the object is not frozen or on error.
   ///
   /// This function thaws the given Edje object.
   ///
   /// @note: If sucessives freezes were done, an equal number of
   /// thaws will be required.
   ///
   /// @see edje_object_freeze()
   ///
   int thaw() const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_thaw());
      return _tmp_ret;
   }

   /// @brief @brief Get the object currently swallowed by a part.
   ///
   /// @return The swallowed object, or NULL if there is none.
   ///
   /// @param part The part name
   ///
   evas::object part_swallow_get(std::string part_) const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_swallow_get(efl::eolian::to_c(part_)));
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Reset the input method context if needed.
   ///
   /// This can be necessary in the case where modifying the buffer would confuse on-going input method behavior
   ///
   /// @since 1.2.0
   ///
   /// @param part The part name
   ///
   void part_text_imf_context_reset(std::string part_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_imf_context_reset(efl::eolian::to_c(part_)));
   }

   /// @brief Set the "return" key type. This type is used to set string or icon on the "return" key of the input panel.
   ///
   /// An input panel displays the string or icon associated with this type
   ///
   /// @since 1.2.0
   ///
   /// @param part The part name
   /// @param return_key_type The type of "return" key on the input panel
   ///
   void part_text_input_panel_return_key_type_set(std::string part_, Edje_Input_Panel_Return_Key_Type return_key_type_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_input_panel_return_key_type_set(efl::eolian::to_c(part_), return_key_type_));
   }

   /// @brief Get the "return" key type.
   ///
   /// @see edje_object_part_text_input_panel_return_key_type_set() for more details
   ///
   /// @return The type of "return" key on the input panel
   /// @since 1.2.0
   ///
   /// @param part The part name
   ///
   Edje_Input_Panel_Return_Key_Type part_text_input_panel_return_key_type_get(std::string part_) const
   {
      Edje_Input_Panel_Return_Key_Type _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_panel_return_key_type_get(efl::eolian::to_c(part_)));
      return _tmp_ret;
   }

   /// @brief @brief Retrieve a child from a table
   ///
   /// @return The child Evas_Object
   ///
   /// @param part The part name
   /// @param col The column of the child to get
   /// @param row The row of the child to get
   ///
   evas::object part_table_child_get(std::string part_, unsigned int col_, unsigned int row_) const
   {
      Evas_Object * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_table_child_get(efl::eolian::to_c(part_), col_, row_));
      return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Adds an object to the box.
   ///
   /// @return @c EINA_TRUE: Successfully added.\n
   /// @c EINA_FALSE: An error occurred.
   ///
   /// Inserts child in the box given by part, in the position marked by
   /// reference.
   ///
   /// @see edje_object_part_box_append()
   /// @see edje_object_part_box_prepend()
   /// @see edje_object_part_box_insert_at()
   ///
   /// @param part The part name
   /// @param child The object to insert
   /// @param reference The object to be used as reference
   ///
   bool part_box_insert_before(std::string part_, evas::object child_, const Evas_Object * reference_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_box_insert_before(efl::eolian::to_c(part_), efl::eolian::to_c(child_), reference_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Set the parameter for the external part.
   ///
   /// Parts of type external may carry extra properties that have
   /// meanings defined by the external plugin. For instance, it may be a
   /// string that defines a button label and setting this property will
   /// change that label on the fly.
   ///
   /// @note external parts have parameters set when they change
   /// states. Those parameters will never be changed by this
   /// function. The interpretation of how state_set parameters and
   /// param_set will interact is up to the external plugin.
   ///
   /// @note this function will not check if parameter value is valid
   /// using #Edje_External_Param_Info minimum, maximum, valid
   /// choices and others. However these should be checked by the
   /// underlying implementation provided by the external
   /// plugin. This is done for performance reasons.
   ///
   /// @return @c EINA_TRUE if everything went fine, @c EINA_FALSE on errors.
   ///
   /// @param part The part name
   /// @param param the parameter details, including its name, type and
   /// actual value. This pointer should be valid, and the
   /// parameter must exist in
   /// #Edje_External_Type.parameters_info, with the exact type,
   /// otherwise the operation will fail and @c EINA_FALSE will be
   /// returned.
   ///
   bool part_external_param_set(std::string part_, const Edje_External_Param * param_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_external_param_set(efl::eolian::to_c(part_), param_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Get the parameter for the external part.
   ///
   /// Parts of type external may carry extra properties that have
   /// meanings defined by the external plugin. For instance, it may be a
   /// string that defines a button label. This property can be modified by
   /// state parameters, by explicit calls to
   /// edje_object_part_external_param_set() or getting the actual object
   /// with edje_object_part_external_object_get() and calling native
   /// functions.
   ///
   /// This function asks the external plugin what is the current value,
   /// independent on how it was set.
   ///
   /// @return @c EINA_TRUE if everything went fine and @p param members
   /// are filled with information, @c EINA_FALSE on errors and @p
   /// param member values are not set or valid.
   ///
   /// @param part The part name
   /// @param[out] param the parameter details. It is used as both input and
   /// output variable. This pointer should be valid, and the
   /// parameter must exist in
   /// #Edje_External_Type.parameters_info, with the exact type,
   /// otherwise the operation will fail and @c EINA_FALSE will be
   /// returned.
   ///
   bool part_external_param_get(std::string part_, Edje_External_Param* param_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_external_param_get(efl::eolian::to_c(part_), param_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Calculate the minimum required size for a given Edje object.
   ///
   /// This call works exactly as edje_object_size_min_restricted_calc(),
   /// with the last two arguments set to 0. Please refer to its
   /// documentation, then.
   ///
   /// @param[out] minw Pointer to a variable where to store the minimum
   /// required width
   /// @param[out] minh Pointer to a variable where to store the minimum
   /// required height
   ///
   void size_min_calc(Evas_Coord* minw_, Evas_Coord* minh_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_size_min_calc(minw_, minh_));
   }

   /// @brief @brief Appends an object to the box.
   ///
   /// @return @c EINA_TRUE: Successfully added.\n
   /// @c EINA_FALSE: An error occurred.
   ///
   /// Appends child to the box indicated by part.
   ///
   /// @see edje_object_part_box_prepend()
   /// @see edje_object_part_box_insert_before()
   /// @see edje_object_part_box_insert_at()
   ///
   /// @param part The part name
   /// @param child The object to append
   ///
   bool part_box_append(std::string part_, evas::object child_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_box_append(efl::eolian::to_c(part_), efl::eolian::to_c(child_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Calculate the minimum required size for a given Edje object.
   ///
   /// This call will trigger an internal recalculation of all parts of
   /// the @p obj object, in order to return its minimum required
   /// dimensions for width and height. The user might choose to @b impose
   /// those minimum sizes, making the resulting calculation to get to values
   /// equal or bigger than @p restrictedw and @p restrictedh, for width and
   /// height, respectively.
   ///
   /// @note At the end of this call, @p obj @b won't be automatically
   /// resized to new dimensions, but just return the calculated
   /// sizes. The caller is the one up to change its geometry or not.
   ///
   /// @warning Be advised that invisible parts in @p obj @b will be taken
   /// into account in this calculation.
   ///
   /// @param[out] minw Pointer to a variable where to store the minimum
   /// required width
   /// @param[out] minh Pointer to a variable where to store the minimum
   /// required height
   /// @param restrictedw Do not allow object's calculated (minimum) width
   /// to be less than this value
   /// @param restrictedh Do not allow object's calculated (minimum)
   /// height to be less than this value
   ///
   void size_min_restricted_calc(Evas_Coord* minw_, Evas_Coord* minh_, Evas_Coord restrictedw_, Evas_Coord restrictedh_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_size_min_restricted_calc(minw_, minh_, restrictedw_, restrictedh_));
   }

   /// @brief @brief Removes all elements from the box.
   ///
   /// @return 1: Successfully cleared.\n
   /// 0: An error occurred.
   ///
   /// Removes all the external objects from the box indicated by part.
   /// Elements created from the theme will not be removed.
   ///
   /// @see edje_object_part_box_remove()
   /// @see edje_object_part_box_remove_at()
   ///
   /// @param part The part name
   /// @param clear Delete objects on removal
   ///
   bool part_box_remove_all(std::string part_, bool clear_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_box_remove_all(efl::eolian::to_c(part_), efl::eolian::to_c(clear_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Pages x,y steps.
   ///
   /// Pages x,y where the increment is defined by
   /// edje_object_part_drag_page_set.
   ///
   /// Values for @p dx and @p dy are real numbers that range from 0 to 1.
   ///
   /// @warning Paging is bugged!
   ///
   /// @see edje_object_part_drag_step()
   ///
   /// @param part The part name
   /// @param dx The x step
   /// @param dy The y step
   ///
   bool part_drag_page(std::string part_, double dx_, double dy_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_page(efl::eolian::to_c(part_), dx_, dy_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Sets the text for an object part
   ///
   /// @return @c EINA_TRUE on success, @c EINA_FALSE otherwise
   ///
   /// @param part The part name
   /// @param text The text string
   ///
   bool part_text_set(std::string part_, std::string text_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_set(efl::eolian::to_c(part_), efl::eolian::to_c(text_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Return the text of the object part.
   ///
   /// @return The text string
   ///
   /// This function returns the text associated to the object part.
   ///
   /// @see edje_object_part_text_set().
   ///
   /// @param part The part name
   ///
   std::string part_text_get(std::string part_) const
   {
      const char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_get(efl::eolian::to_c(part_)));
      return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Set the attribute to show the input panel in case of only an user's explicit Mouse Up event.
   /// It doesn't request to show the input panel even though it has focus.
   ///
   /// @since 1.9.0
   ///
   /// @param part The part name
   /// @param ondemand If true, the input panel will be shown in case of only Mouse up event. (Focus event will be ignored.)
   ///
   void part_text_input_panel_show_on_demand_set(std::string part_, bool ondemand_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_input_panel_show_on_demand_set(efl::eolian::to_c(part_), efl::eolian::to_c(ondemand_)));
   }

   /// @brief Get the attribute to show the input panel in case of only an user's explicit Mouse Up event.
   ///
   /// @return @c EINA_TRUE if the input panel will be shown in case of only Mouse up event.
   /// @since 1.9.0
   ///
   /// @param part The part name
   ///
   bool part_text_input_panel_show_on_demand_get(std::string part_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_panel_show_on_demand_get(efl::eolian::to_c(part_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Sets the input hint which allows input methods to fine-tune their behavior.
   ///
   /// @since 1.12.0
   ///
   /// @param part The part name
   /// @param input_hints input hints
   ///
   void part_text_input_hint_set(std::string part_, Edje_Input_Hints input_hints_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_input_hint_set(efl::eolian::to_c(part_), input_hints_));
   }

   /// @brief Gets the value of input hint
   ///
   /// @return The value of input hint
   /// @since 1.12.0
   ///
   /// @param part The part name
   ///
   Edje_Input_Hints part_text_input_hint_get(std::string part_) const
   {
      Edje_Input_Hints _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_hint_get(efl::eolian::to_c(part_)));
      return _tmp_ret;
   }

   /// @brief @brief Return the selection text of the object part.
   ///
   /// @return The text string
   ///
   /// This function returns selection text of the object part.
   ///
   /// @see edje_object_part_text_select_all()
   /// @see edje_object_part_text_select_none()
   ///
   /// @param part The part name
   ///
   std::string part_text_selection_get(std::string part_) const
   {
      const char * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_selection_get(efl::eolian::to_c(part_)));
      return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Returns whether the cursor points to a format.
   /// @see evas_textblock_cursor_is_format
   ///
   /// @return EINA_TRUE if it's true, EINA_FALSE otherwise.
   ///
   /// @param part The part name
   /// @param cur The cursor to adjust.
   ///
   bool part_text_cursor_is_format_get(std::string part_, Edje_Cursor cur_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_is_format_get(efl::eolian::to_c(part_), cur_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Sets the object color class.
   ///
   /// This function sets the color values for an object level color
   /// class. This will cause all edje parts in the specified object that
   /// have the specified color class to have their colors multiplied by
   /// these values.
   ///
   /// The first color is the object, the second is the text outline, and
   /// the third is the text shadow. (Note that the second two only apply
   /// to text parts).
   ///
   /// Setting color emits a signal "color_class,set" with source being
   /// the given color.
   ///
   /// @note unlike Evas, Edje colors are @b not pre-multiplied. That is,
   /// half-transparent white is 255 255 255 128.
   ///
   /// @param color_class 
   /// @param r Object Red value
   /// @param g Object Green value
   /// @param b Object Blue value
   /// @param a Object Alpha value
   /// @param r2 Outline Red value
   /// @param g2 Outline Green value
   /// @param b2 Outline Blue value
   /// @param a2 Outline Alpha value
   /// @param r3 Shadow Red value
   /// @param g3 Shadow Green value
   /// @param b3 Shadow Blue value
   /// @param a3 Shadow Alpha value
   ///
   bool color_class_set(std::string color_class_, int r_, int g_, int b_, int a_, int r2_, int g2_, int b2_, int a2_, int r3_, int g3_, int b3_, int a3_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_color_class_set(efl::eolian::to_c(color_class_), r_, g_, b_, a_, r2_, g2_, b2_, a2_, r3_, g3_, b3_, a3_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Gets the object color class.
   ///
   /// @return EINA_TRUE if found or EINA_FALSE if not found and all
   /// values are zeroed.
   ///
   /// This function gets the color values for an object level color
   /// class. If no explicit object color is set, then global values will
   /// be used.
   ///
   /// The first color is the object, the second is the text outline, and
   /// the third is the text shadow. (Note that the second two only apply
   /// to text parts).
   ///
   /// @note unlike Evas, Edje colors are @b not pre-multiplied. That is,
   /// half-transparent white is 255 255 255 128.
   ///
   /// @param color_class 
   /// @param[out] r Object Red value
   /// @param[out] g Object Green value
   /// @param[out] b Object Blue value
   /// @param[out] a Object Alpha value
   /// @param[out] r2 Outline Red value
   /// @param[out] g2 Outline Green value
   /// @param[out] b2 Outline Blue value
   /// @param[out] a2 Outline Alpha value
   /// @param[out] r3 Shadow Red value
   /// @param[out] g3 Shadow Green value
   /// @param[out] b3 Shadow Blue value
   /// @param[out] a3 Shadow Alpha value
   ///
   bool color_class_get(std::string color_class_, int* r_, int* g_, int* b_, int* a_, int* r2_, int* g2_, int* b2_, int* a2_, int* r3_, int* g3_, int* b3_, int* a3_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_color_class_get(efl::eolian::to_c(color_class_), r_, g_, b_, a_, r2_, g2_, b2_, a2_, r3_, g3_, b3_, a3_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Steps the dragable x,y steps.
   ///
   /// Steps x,y where the step increment is the amount set by
   /// edje_object_part_drag_step_set.
   ///
   /// Values for @p dx and @p dy are real numbers that range from 0 to 1.
   ///
   /// @see edje_object_part_drag_page()
   ///
   /// @param part The part name
   /// @param dx The x step
   /// @param dy The y step
   ///
   bool part_drag_step(std::string part_, double dx_, double dy_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_step(efl::eolian::to_c(part_), dx_, dy_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Move the cursor to the char above the current cursor position.
   ///
   /// @param part The part name
   /// @param cur the edje cursor to work on
   ///
   bool part_text_cursor_up(std::string part_, Edje_Cursor cur_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_up(efl::eolian::to_c(part_), cur_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Returns the cursor geometry of the part relative to the edje
   /// object.
   ///
   /// @param part The part name
   /// @param[out] x Cursor X position
   /// @param[out] y Cursor Y position
   /// @param[out] w Cursor width
   /// @param[out] h Cursor height
   ///
   void part_text_cursor_geometry_get(std::string part_, Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_cursor_geometry_get(efl::eolian::to_c(part_), x_, y_, w_, h_));
   }

   /// @brief @brief Return a list of char anchor names.
   ///
   /// @return The list of anchors (const char *), do not modify!
   ///
   /// This function returns a list of char anchor names.
   ///
   /// @param part The part name
   ///
   efl::eina::crange_list< std::string > part_text_anchor_list_get(std::string part_) const
   {
      const Eina_List * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_anchor_list_get(efl::eolian::to_c(part_)));
      return efl::eolian::to_cxx<efl::eina::crange_list< std::string >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
   }

   /// @brief Add a filter function for newly inserted text.
   ///
   /// Whenever text is inserted (not the same as set) into the given @p part,
   /// the list of filter functions will be called to decide if and how the new
   /// text will be accepted.
   /// There are three types of filters, EDJE_TEXT_FILTER_TEXT,
   /// EDJE_TEXT_FILTER_FORMAT and EDJE_TEXT_FILTER_MARKUP.
   /// The text parameter in the @p func filter can be modified by the user and
   /// it's up to him to free the one passed if he's to change the pointer. If
   /// doing so, the newly set text should be malloc'ed, as once all the filters
   /// are called Edje will free it.
   /// If the text is to be rejected, freeing it and setting the pointer to NULL
   /// will make Edje break out of the filter cycle and reject the inserted
   /// text.
   ///
   /// @warning This function will be deprecated because of difficulty in use.
   /// The type(format, text, or markup) of text should be always
   /// checked in the filter function for correct filtering.
   /// Please use edje_object_text_markup_filter_callback_add() instead. There
   /// is no need to check the type of text in the filter function
   /// because the text is always markup.
   /// @warning If you use this function with
   /// edje_object_text_markup_filter_callback_add() together, all
   /// Edje_Text_Filter_Cb functions and Edje_Markup_Filter_Cb functions
   /// will be executed, and then filtered text will be inserted.
   ///
   /// @see edje_object_text_insert_filter_callback_del
   /// @see edje_object_text_insert_filter_callback_del_full
   /// @see edje_object_text_markup_filter_callback_add
   ///
   /// @param part The part name
   /// @param func The callback function that will act as filter
   /// @param data User provided data to pass to the filter function
   ///
   void text_insert_filter_callback_add(std::string part_, Edje_Text_Filter_Cb func_, void * data_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_text_insert_filter_callback_add(efl::eolian::to_c(part_), func_, data_));
   }

   /// @brief @brief Show the input panel (virtual keyboard) based on the input panel property such as layout, autocapital types, and so on.
   ///
   /// Note that input panel is shown or hidden automatically according to the focus state.
   /// This API can be used in the case of manually controlling by using edje_object_part_text_input_panel_enabled_set.
   ///
   /// @since 1.2.0
   ///
   /// @param part The part name
   ///
   void part_text_input_panel_show(std::string part_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_input_panel_show(efl::eolian::to_c(part_)));
   }

   /// @brief @brief Check if an Edje part exists in a given Edje object's group
   /// definition.
   ///
   /// @return @c EINA_TRUE, if the Edje part exists in @p obj's group or
   /// @c EINA_FALSE, otherwise (and on errors)
   ///
   /// This function returns if a given part exists in the Edje group
   /// bound to object @p obj (with edje_object_file_set()).
   ///
   /// This call is useful, for example, when one could expect or not a
   /// given GUI element, depending on the @b theme applied to @p obj.
   ///
   /// @param part The part's name to check for existence in @p obj's
   /// group
   ///
   bool part_exists(std::string part_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_exists(efl::eolian::to_c(part_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief Delete a function from the markup filter list.
   ///
   /// Delete the given @p func filter from the list in @p part. Returns
   /// the user data pointer given when added.
   ///
   /// @see edje_object_text_markup_filter_callback_add
   /// @see edje_object_text_markup_filter_callback_del_full
   ///
   /// @return The user data pointer if successful, or NULL otherwise
   /// @since 1.2.0
   ///
   /// @param part The part name
   /// @param func The function callback to remove
   ///
   void * text_markup_filter_callback_del(std::string part_, Edje_Markup_Filter_Cb func_) const
   {
      void * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_text_markup_filter_callback_del(efl::eolian::to_c(part_), func_));
      return _tmp_ret;
   }

   /// @brief @brief Return true if the cursor points to a visible format
   /// For example \\t, \\n, item and etc.
   /// @see  evas_textblock_cursor_format_is_visible_get
   ///
   /// @param part The part name
   /// @param cur The cursor to adjust.
   ///
   bool part_text_cursor_is_visible_format_get(std::string part_, Edje_Cursor cur_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_is_visible_format_get(efl::eolian::to_c(part_), cur_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief This function inserts text as if the user has inserted it.
   ///
   /// This means it actually registers as a change and emits signals, triggers
   /// callbacks as appropriate.
   ///
   /// @since 1.2.0
   ///
   /// @param part The part name
   /// @param text The text string
   ///
   void part_text_user_insert(std::string part_, std::string text_) const
   {
      eo_do(_eo_ptr(), ::edje_obj_part_text_user_insert(efl::eolian::to_c(part_), efl::eolian::to_c(text_)));
   }

   /// @brief @brief Moves the cursor to the previous char
   /// @see evas_textblock_cursor_char_prev
   ///
   /// @param part The part name
   /// @param cur the edje cursor to work on
   ///
   bool part_text_cursor_prev(std::string part_, Edje_Cursor cur_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_prev(efl::eolian::to_c(part_), cur_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @brief @brief Return a list of char item names.
   ///
   /// @return The list of items (const char *), do not modify!
   ///
   /// This function returns a list of char item names.
   ///
   /// @param part The part name
   ///
   efl::eina::crange_list< std::string > part_text_item_list_get(std::string part_) const
   {
      const Eina_List * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_text_item_list_get(efl::eolian::to_c(part_)));
      return efl::eolian::to_cxx<efl::eina::crange_list< std::string >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
   }

   /// @brief @brief "Swallows" an object into one of the Edje object @c SWALLOW
   /// parts.
   ///
   /// Swallowing an object into an Edje object is, for a given part of
   /// type @c SWALLOW in the EDC group which gave life to @a obj, to set
   /// an external object to be controlled by @a obj, being displayed
   /// exactly over that part's region inside the whole Edje object's
   /// viewport.
   ///
   /// From this point on, @a obj will have total control over @a
   /// obj_swallow's geometry and visibility. For instance, if @a obj is
   /// visible, as in @c evas_object_show(), the swallowed object will be
   /// visible too -- if the given @c SWALLOW part it's in is also
   /// visible. Other actions on @a obj will also reflect on the swallowed
   /// object as well (e.g. resizing, moving, raising/lowering, etc.).
   ///
   /// Finally, all internal changes to @a part, specifically, will
   /// reflect on the displaying of @a obj_swallow, for example state
   /// changes leading to different visibility states, geometries,
   /// positions, etc.
   ///
   /// If an object has already been swallowed into this part, then it
   /// will first be unswallowed (as in edje_object_part_unswallow())
   /// before the new object is swallowed.
   ///
   /// @note @a obj @b won't delete the swallowed object once it is
   /// deleted -- @a obj_swallow will get to an unparented state again.
   ///
   /// For more details on EDC @c SWALLOW parts, see @ref edcref "syntax
   /// reference".
   ///
   /// @param part The swallow part's name
   /// @param obj_swallow The object to occupy that part
   ///
   bool part_swallow(std::string part_, evas::object obj_swallow_) const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::edje_obj_part_swallow(efl::eolian::to_c(part_), efl::eolian::to_c(obj_swallow_)));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

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

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

};
} 

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

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

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

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

template <typename T>
void edje_object_move_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord x_, Evas_Coord y_)
{
   static_cast<T*>(self->this_)->move(x_, y_);
}

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

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

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

template <typename T>
bool edje_object_file_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * file_, const char * key_)
{
   return static_cast<T*>(self->this_)->file_set(efl::eolian::to_cxx<std::string>(file_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(key_, std::tuple<std::false_type>()));
}

template <typename T>
void edje_object_file_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char ** file_, const char ** key_)
{
   static_cast<T*>(self->this_)->file_get(file_, key_);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
bool edje_object_mmap_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const Eina_File * file_, const char * group_)
{
   return static_cast<T*>(self->this_)->mmap_set(file_, efl::eolian::to_cxx<std::string>(group_, std::tuple<std::false_type>()));
}

template <typename T>
void edje_object_text_change_cb_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Edje_Text_Change_Cb func_, void * data_)
{
   static_cast<T*>(self->this_)->text_change_cb_set(func_, data_);
}

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

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

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

template <typename T>
bool edje_object_part_text_cursor_coord_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Cursor cur_, Evas_Coord x_, Evas_Coord y_)
{
   return static_cast<T*>(self->this_)->part_text_cursor_coord_set(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), cur_, x_, y_);
}

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

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

template <typename T>
void edje_object_item_provider_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Edje_Item_Provider_Cb func_, void * data_)
{
   static_cast<T*>(self->this_)->item_provider_set(func_, data_);
}

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

template <typename T>
void edje_object_message_handler_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Edje_Message_Handler_Cb func_, void * data_)
{
   static_cast<T*>(self->this_)->message_handler_set(func_, data_);
}

template <typename T>
void edje_object_size_min_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* minw_, Evas_Coord* minh_)
{
   static_cast<T*>(self->this_)->size_min_get(minw_, minh_);
}

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

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

template <typename T>
void edje_object_size_max_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* maxw_, Evas_Coord* maxh_)
{
   static_cast<T*>(self->this_)->size_max_get(maxw_, maxh_);
}

template <typename T>
bool edje_object_part_table_clear_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Eina_Bool clear_)
{
   return static_cast<T*>(self->this_)->part_table_clear(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<bool>(clear_, std::tuple<std::false_type>()));
}

template <typename T>
Edje_External_Param_Type edje_object_part_external_param_type_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, const char* param_)
{
   return static_cast<T*>(self->this_)->part_external_param_type_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), param_);
}

template <typename T>
void edje_object_part_text_select_allow_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Eina_Bool allow_)
{
   static_cast<T*>(self->this_)->part_text_select_allow_set(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<bool>(allow_, std::tuple<std::false_type>()));
}

template <typename T>
std::string edje_object_part_state_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, double* val_ret_)
{
   return static_cast<T*>(self->this_)->part_state_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), val_ret_);
}

template <typename T>
void * edje_object_text_markup_filter_callback_del_full_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Markup_Filter_Cb func_, void * data_)
{
   return static_cast<T*>(self->this_)->text_markup_filter_callback_del_full(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), func_, data_);
}

template <typename T>
bool edje_object_part_drag_step_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, double dx_, double dy_)
{
   return static_cast<T*>(self->this_)->part_drag_step_set(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), dx_, dy_);
}

template <typename T>
bool edje_object_part_drag_step_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, double* dx_, double* dy_)
{
   return static_cast<T*>(self->this_)->part_drag_step_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), dx_, dy_);
}

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

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

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

template <typename T>
void * edje_object_signal_callback_del_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * emission_, const char * source_, Edje_Signal_Cb func_, void * data_)
{
   return static_cast<T*>(self->this_)->signal_callback_del(efl::eolian::to_cxx<std::string>(emission_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(source_, std::tuple<std::false_type>()), func_, data_);
}

template <typename T>
bool edje_object_part_text_cursor_next_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Cursor cur_)
{
   return static_cast<T*>(self->this_)->part_text_cursor_next(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), cur_);
}

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

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

template <typename T>
bool edje_object_part_geometry_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
{
   return static_cast<T*>(self->this_)->part_geometry_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), x_, y_, w_, h_);
}

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

template <typename T>
bool edje_object_part_text_item_geometry_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, const char * item_, Evas_Coord* cx_, Evas_Coord* cy_, Evas_Coord* cw_, Evas_Coord* ch_)
{
   return static_cast<T*>(self->this_)->part_text_item_geometry_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(item_, std::tuple<std::false_type>()), cx_, cy_, cw_, ch_);
}

template <typename T>
bool edje_object_part_table_unpack_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Evas_Object * child_obj_)
{
   return static_cast<T*>(self->this_)->part_table_unpack(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<evas::object>(child_obj_, std::tuple<std::false_type>()));
}

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

template <typename T>
void * edje_object_text_insert_filter_callback_del_full_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Text_Filter_Cb func_, void * data_)
{
   return static_cast<T*>(self->this_)->text_insert_filter_callback_del_full(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), func_, data_);
}

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

template <typename T>
void edje_object_part_text_input_panel_imdata_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, const void * data_, int len_)
{
   static_cast<T*>(self->this_)->part_text_input_panel_imdata_set(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), data_, len_);
}

template <typename T>
void edje_object_part_text_input_panel_imdata_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, void * data_, int * len_)
{
   static_cast<T*>(self->this_)->part_text_input_panel_imdata_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), data_, len_);
}

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

template <typename T>
evas::object edje_object_part_box_remove_at_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, unsigned int pos_)
{
   return static_cast<T*>(self->this_)->part_box_remove_at(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), pos_);
}

template <typename T>
void edje_object_part_text_cursor_copy_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Cursor src_, Edje_Cursor dst_)
{
   static_cast<T*>(self->this_)->part_text_cursor_copy(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), src_, dst_);
}

template <typename T>
bool edje_object_parts_extends_calc_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
{
   return static_cast<T*>(self->this_)->parts_extends_calc(x_, y_, w_, h_);
}

template <typename T>
bool edje_object_part_drag_value_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, double dx_, double dy_)
{
   return static_cast<T*>(self->this_)->part_drag_value_set(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), dx_, dy_);
}

template <typename T>
bool edje_object_part_drag_value_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, double* dx_, double* dy_)
{
   return static_cast<T*>(self->this_)->part_drag_value_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), dx_, dy_);
}

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

template <typename T>
void edje_object_part_text_cursor_pos_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Cursor cur_, int pos_)
{
   static_cast<T*>(self->this_)->part_text_cursor_pos_set(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), cur_, pos_);
}

template <typename T>
int edje_object_part_text_cursor_pos_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Cursor cur_)
{
   return static_cast<T*>(self->this_)->part_text_cursor_pos_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), cur_);
}

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

template <typename T>
char * edje_object_part_text_cursor_content_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Cursor cur_)
{
   return static_cast<T*>(self->this_)->part_text_cursor_content_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), cur_);
}

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

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

template <typename T>
bool edje_object_part_table_pack_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Evas_Object * child_obj_, unsigned short col_, unsigned short row_, unsigned short colspan_, unsigned short rowspan_)
{
   return static_cast<T*>(self->this_)->part_table_pack(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<evas::object>(child_obj_, std::tuple<std::false_type>()), col_, row_, colspan_, rowspan_);
}

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

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

template <typename T>
bool edje_object_part_table_col_row_size_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, int* cols_, int* rows_)
{
   return static_cast<T*>(self->this_)->part_table_col_row_size_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), cols_, rows_);
}

template <typename T>
evas::object edje_object_part_external_object_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_)
{
   return static_cast<T*>(self->this_)->part_external_object_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()));
}

template <typename T>
evas::object edje_object_part_external_content_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, const char* content_)
{
   return static_cast<T*>(self->this_)->part_external_content_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), content_);
}

template <typename T>
bool edje_object_preload_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool cancel_)
{
   return static_cast<T*>(self->this_)->preload(efl::eolian::to_cxx<bool>(cancel_, std::tuple<std::false_type>()));
}

template <typename T>
void edje_object_part_text_input_panel_enabled_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Eina_Bool enabled_)
{
   static_cast<T*>(self->this_)->part_text_input_panel_enabled_set(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<bool>(enabled_, std::tuple<std::false_type>()));
}

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

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

template <typename T>
bool edje_object_part_box_insert_at_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Evas_Object * child_, unsigned int pos_)
{
   return static_cast<T*>(self->this_)->part_box_insert_at(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()), pos_);
}

template <typename T>
efl::eina::crange_list< const Evas_Textblock_Rectangle * > edje_object_part_text_anchor_geometry_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, const char * anchor_)
{
   return static_cast<T*>(self->this_)->part_text_anchor_geometry_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(anchor_, std::tuple<std::false_type>()));
}

template <typename T>
bool edje_object_part_text_cursor_down_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Cursor cur_)
{
   return static_cast<T*>(self->this_)->part_text_cursor_down(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), cur_);
}

template <typename T>
bool edje_object_part_drag_page_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, double dx_, double dy_)
{
   return static_cast<T*>(self->this_)->part_drag_page_set(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), dx_, dy_);
}

template <typename T>
bool edje_object_part_drag_page_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, double* dx_, double* dy_)
{
   return static_cast<T*>(self->this_)->part_drag_page_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), dx_, dy_);
}

template <typename T>
bool edje_object_part_box_prepend_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Evas_Object * child_)
{
   return static_cast<T*>(self->this_)->part_box_prepend(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()));
}

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

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

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

template <typename T>
void edje_object_message_send_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Edje_Message_Type type_, int id_, void * msg_)
{
   static_cast<T*>(self->this_)->message_send(type_, id_, msg_);
}

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

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

template <typename T>
bool edje_object_part_drag_size_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, double dw_, double dh_)
{
   return static_cast<T*>(self->this_)->part_drag_size_set(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), dw_, dh_);
}

template <typename T>
bool edje_object_part_drag_size_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, double* dw_, double* dh_)
{
   return static_cast<T*>(self->this_)->part_drag_size_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), dw_, dh_);
}

template <typename T>
void * edje_object_text_insert_filter_callback_del_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Text_Filter_Cb func_)
{
   return static_cast<T*>(self->this_)->text_insert_filter_callback_del(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), func_);
}

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

template <typename T>
bool edje_object_part_text_unescaped_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, const char * text_to_escape_)
{
   return static_cast<T*>(self->this_)->part_text_unescaped_set(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(text_to_escape_, std::tuple<std::false_type>()));
}

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

template <typename T>
void edje_object_signal_callback_add_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * emission_, const char * source_, Edje_Signal_Cb func_, void * data_)
{
   static_cast<T*>(self->this_)->signal_callback_add(efl::eolian::to_cxx<std::string>(emission_, std::tuple<std::false_type>()), efl::eolian::to_cxx<std::string>(source_, std::tuple<std::false_type>()), func_, data_);
}

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

template <typename T>
void edje_object_part_text_input_panel_return_key_disabled_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Eina_Bool disabled_)
{
   static_cast<T*>(self->this_)->part_text_input_panel_return_key_disabled_set(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<bool>(disabled_, std::tuple<std::false_type>()));
}

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

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

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

template <typename T>
void edje_object_part_unswallow_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Object * obj_swallow_)
{
   static_cast<T*>(self->this_)->part_unswallow(efl::eolian::to_cxx<evas::object>(obj_swallow_, std::tuple<std::false_type>()));
}

template <typename T>
void edje_object_part_text_prediction_allow_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Eina_Bool prediction_)
{
   static_cast<T*>(self->this_)->part_text_prediction_allow_set(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<bool>(prediction_, std::tuple<std::false_type>()));
}

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

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

template <typename T>
void edje_object_text_markup_filter_callback_add_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Markup_Filter_Cb func_, void * data_)
{
   static_cast<T*>(self->this_)->text_markup_filter_callback_add(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), func_, data_);
}

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

template <typename T>
evas::object edje_object_part_box_remove_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Evas_Object * child_)
{
   return static_cast<T*>(self->this_)->part_box_remove(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()));
}

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

template <typename T>
evas::object edje_object_part_swallow_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_)
{
   return static_cast<T*>(self->this_)->part_swallow_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()));
}

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

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

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

template <typename T>
evas::object edje_object_part_table_child_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, unsigned int col_, unsigned int row_)
{
   return static_cast<T*>(self->this_)->part_table_child_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), col_, row_);
}

template <typename T>
bool edje_object_part_box_insert_before_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Evas_Object * child_, const Evas_Object * reference_)
{
   return static_cast<T*>(self->this_)->part_box_insert_before(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()), reference_);
}

template <typename T>
bool edje_object_part_external_param_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, const Edje_External_Param * param_)
{
   return static_cast<T*>(self->this_)->part_external_param_set(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), param_);
}

template <typename T>
bool edje_object_part_external_param_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_External_Param* param_)
{
   return static_cast<T*>(self->this_)->part_external_param_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), param_);
}

template <typename T>
void edje_object_size_min_calc_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* minw_, Evas_Coord* minh_)
{
   static_cast<T*>(self->this_)->size_min_calc(minw_, minh_);
}

template <typename T>
bool edje_object_part_box_append_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Evas_Object * child_)
{
   return static_cast<T*>(self->this_)->part_box_append(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<evas::object>(child_, std::tuple<std::false_type>()));
}

template <typename T>
void edje_object_size_min_restricted_calc_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* minw_, Evas_Coord* minh_, Evas_Coord restrictedw_, Evas_Coord restrictedh_)
{
   static_cast<T*>(self->this_)->size_min_restricted_calc(minw_, minh_, restrictedw_, restrictedh_);
}

template <typename T>
bool edje_object_part_box_remove_all_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Eina_Bool clear_)
{
   return static_cast<T*>(self->this_)->part_box_remove_all(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<bool>(clear_, std::tuple<std::false_type>()));
}

template <typename T>
bool edje_object_part_drag_page_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, double dx_, double dy_)
{
   return static_cast<T*>(self->this_)->part_drag_page(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), dx_, dy_);
}

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

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

template <typename T>
void edje_object_part_text_input_panel_show_on_demand_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Eina_Bool ondemand_)
{
   static_cast<T*>(self->this_)->part_text_input_panel_show_on_demand_set(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<bool>(ondemand_, std::tuple<std::false_type>()));
}

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

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

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

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

template <typename T>
bool edje_object_part_text_cursor_is_format_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Cursor cur_)
{
   return static_cast<T*>(self->this_)->part_text_cursor_is_format_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), cur_);
}

template <typename T>
bool edje_object_color_class_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * color_class_, int r_, int g_, int b_, int a_, int r2_, int g2_, int b2_, int a2_, int r3_, int g3_, int b3_, int a3_)
{
   return static_cast<T*>(self->this_)->color_class_set(efl::eolian::to_cxx<std::string>(color_class_, std::tuple<std::false_type>()), r_, g_, b_, a_, r2_, g2_, b2_, a2_, r3_, g3_, b3_, a3_);
}

template <typename T>
bool edje_object_color_class_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * color_class_, int* r_, int* g_, int* b_, int* a_, int* r2_, int* g2_, int* b2_, int* a2_, int* r3_, int* g3_, int* b3_, int* a3_)
{
   return static_cast<T*>(self->this_)->color_class_get(efl::eolian::to_cxx<std::string>(color_class_, std::tuple<std::false_type>()), r_, g_, b_, a_, r2_, g2_, b2_, a2_, r3_, g3_, b3_, a3_);
}

template <typename T>
bool edje_object_part_drag_step_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, double dx_, double dy_)
{
   return static_cast<T*>(self->this_)->part_drag_step(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), dx_, dy_);
}

template <typename T>
bool edje_object_part_text_cursor_up_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Cursor cur_)
{
   return static_cast<T*>(self->this_)->part_text_cursor_up(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), cur_);
}

template <typename T>
void edje_object_part_text_cursor_geometry_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
{
   static_cast<T*>(self->this_)->part_text_cursor_geometry_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), x_, y_, w_, h_);
}

template <typename T>
efl::eina::crange_list< std::string > edje_object_part_text_anchor_list_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_)
{
   return static_cast<T*>(self->this_)->part_text_anchor_list_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()));
}

template <typename T>
void edje_object_text_insert_filter_callback_add_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Text_Filter_Cb func_, void * data_)
{
   static_cast<T*>(self->this_)->text_insert_filter_callback_add(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), func_, data_);
}

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

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

template <typename T>
void * edje_object_text_markup_filter_callback_del_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Markup_Filter_Cb func_)
{
   return static_cast<T*>(self->this_)->text_markup_filter_callback_del(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), func_);
}

template <typename T>
bool edje_object_part_text_cursor_is_visible_format_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Cursor cur_)
{
   return static_cast<T*>(self->this_)->part_text_cursor_is_visible_format_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), cur_);
}

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

template <typename T>
bool edje_object_part_text_cursor_prev_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Edje_Cursor cur_)
{
   return static_cast<T*>(self->this_)->part_text_cursor_prev(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), cur_);
}

template <typename T>
efl::eina::crange_list< std::string > edje_object_part_text_item_list_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_)
{
   return static_cast<T*>(self->this_)->part_text_item_list_get(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()));
}

template <typename T>
bool edje_object_part_swallow_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, const char * part_, Evas_Object * obj_swallow_)
{
   return static_cast<T*>(self->this_)->part_swallow(efl::eolian::to_cxx<std::string>(part_, std::tuple<std::false_type>()), efl::eolian::to_cxx<evas::object>(obj_swallow_, std::tuple<std::false_type>()));
}

namespace efl { namespace eo { namespace detail {

template<>
struct operations< edje::object >
{
   template <typename T>
   struct type
   {
      virtual void dbg_info_get(Eo_Dbg_Info * root_node_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::eo_dbg_info_get(root_node_));
      }

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

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

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

      virtual void move(Evas_Coord x_, Evas_Coord y_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_obj_smart_move(x_, y_));
      }

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

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

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

      virtual bool file_set(std::string file_, std::string key_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::efl_file_set(efl::eolian::to_c(file_), efl::eolian::to_c(key_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void file_get(const char ** file_, const char ** key_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::efl_file_get(file_, key_));
      }

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

      virtual void update_hints_set(bool update_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_update_hints_set(efl::eolian::to_c(update_)));
      }

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

      virtual void mirrored_set(bool rtl_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_mirrored_set(efl::eolian::to_c(rtl_)));
      }

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

      virtual void animation_set(bool on_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_animation_set(efl::eolian::to_c(on_)));
      }

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

      virtual void play_set(bool play_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_play_set(efl::eolian::to_c(play_)));
      }

      virtual const Edje_Perspective * perspective_get()
      {
         const Edje_Perspective * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_perspective_get());
            return _tmp_ret;
      }

      virtual void perspective_set(Edje_Perspective * ps_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_perspective_set(ps_));
      }

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

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

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

      virtual bool mmap_set(const Eina_File * file_, std::string group_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_mmap_set(file_, efl::eolian::to_c(group_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void text_change_cb_set(Edje_Text_Change_Cb func_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_text_change_cb_set(func_, data_));
      }

      virtual void part_text_cursor_begin_set(std::string part_, Edje_Cursor cur_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_cursor_begin_set(efl::eolian::to_c(part_), cur_));
      }

      virtual void part_text_cursor_line_end_set(std::string part_, Edje_Cursor cur_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_cursor_line_end_set(efl::eolian::to_c(part_), cur_));
      }

      virtual bool text_class_set(std::string text_class_, std::string font_, Evas_Font_Size size_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_text_class_set(efl::eolian::to_c(text_class_), efl::eolian::to_c(font_), size_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_text_cursor_coord_set(std::string part_, Edje_Cursor cur_, Evas_Coord x_, Evas_Coord y_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_cursor_coord_set(efl::eolian::to_c(part_), cur_, x_, y_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void part_text_cursor_end_set(std::string part_, Edje_Cursor cur_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_cursor_end_set(efl::eolian::to_c(part_), cur_));
      }

      virtual bool part_text_escaped_set(std::string part_, std::string text_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_escaped_set(efl::eolian::to_c(part_), efl::eolian::to_c(text_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void item_provider_set(Edje_Item_Provider_Cb func_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_item_provider_set(func_, data_));
      }

      virtual void part_text_cursor_line_begin_set(std::string part_, Edje_Cursor cur_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_cursor_line_begin_set(efl::eolian::to_c(part_), cur_));
      }

      virtual void message_handler_set(Edje_Message_Handler_Cb func_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_message_handler_set(func_, data_));
      }

      virtual void size_min_get(Evas_Coord* minw_, Evas_Coord* minh_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_size_min_get(minw_, minh_));
      }

      virtual efl::eina::range_list< std::string > access_part_list_get()
      {
         Eina_List * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_access_part_list_get());
            return efl::eolian::to_cxx<efl::eina::range_list< std::string >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      virtual Edje_Load_Error load_error_get()
      {
         Edje_Load_Error _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_load_error_get());
            return _tmp_ret;
      }

      virtual void size_max_get(Evas_Coord* maxw_, Evas_Coord* maxh_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_size_max_get(maxw_, maxh_));
      }

      virtual bool part_table_clear(std::string part_, bool clear_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_table_clear(efl::eolian::to_c(part_), efl::eolian::to_c(clear_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual Edje_External_Param_Type part_external_param_type_get(std::string part_, const char* param_)
      {
         Edje_External_Param_Type _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_external_param_type_get(efl::eolian::to_c(part_), param_));
            return _tmp_ret;
      }

      virtual void part_text_select_allow_set(std::string part_, bool allow_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_select_allow_set(efl::eolian::to_c(part_), efl::eolian::to_c(allow_)));
      }

      virtual std::string part_state_get(std::string part_, double* val_ret_)
      {
         const char * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_state_get(efl::eolian::to_c(part_), val_ret_));
            return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void * text_markup_filter_callback_del_full(std::string part_, Edje_Markup_Filter_Cb func_, void * data_)
      {
         void * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_text_markup_filter_callback_del_full(efl::eolian::to_c(part_), func_, data_));
            return _tmp_ret;
      }

      virtual bool part_drag_step_set(std::string part_, double dx_, double dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_drag_step_set(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_drag_step_get(std::string part_, double* dx_, double* dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_drag_step_get(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void * part_text_imf_context_get(std::string part_)
      {
         void * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_imf_context_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

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

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

      virtual void * signal_callback_del(std::string emission_, std::string source_, Edje_Signal_Cb func_, void * data_)
      {
         void * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_signal_callback_del(efl::eolian::to_c(emission_), efl::eolian::to_c(source_), func_, data_));
            return _tmp_ret;
      }

      virtual bool part_text_cursor_next(std::string part_, Edje_Cursor cur_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_cursor_next(efl::eolian::to_c(part_), cur_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void part_text_style_user_push(std::string part_, std::string style_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_style_user_push(efl::eolian::to_c(part_), efl::eolian::to_c(style_)));
      }

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

      virtual bool part_geometry_get(std::string part_, Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_geometry_get(efl::eolian::to_c(part_), x_, y_, w_, h_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      virtual bool part_text_item_geometry_get(std::string part_, std::string item_, 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 = ::edje_obj_part_text_item_geometry_get(efl::eolian::to_c(part_), efl::eolian::to_c(item_), cx_, cy_, cw_, ch_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_table_unpack(std::string part_, evas::object child_obj_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_table_unpack(efl::eolian::to_c(part_), efl::eolian::to_c(child_obj_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      virtual void * text_insert_filter_callback_del_full(std::string part_, Edje_Text_Filter_Cb func_, void * data_)
      {
         void * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_text_insert_filter_callback_del_full(efl::eolian::to_c(part_), func_, data_));
            return _tmp_ret;
      }

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

      virtual void part_text_input_panel_imdata_set(std::string part_, const void * data_, int len_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_input_panel_imdata_set(efl::eolian::to_c(part_), data_, len_));
      }

      virtual void part_text_input_panel_imdata_get(std::string part_, void * data_, int * len_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_input_panel_imdata_get(efl::eolian::to_c(part_), data_, len_));
      }

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

      virtual evas::object part_box_remove_at(std::string part_, unsigned int pos_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_box_remove_at(efl::eolian::to_c(part_), pos_));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void part_text_cursor_copy(std::string part_, Edje_Cursor src_, Edje_Cursor dst_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_cursor_copy(efl::eolian::to_c(part_), src_, dst_));
      }

      virtual bool parts_extends_calc(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_parts_extends_calc(x_, y_, w_, h_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_drag_value_set(std::string part_, double dx_, double dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_drag_value_set(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_drag_value_get(std::string part_, double* dx_, double* dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_drag_value_get(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      virtual void part_text_cursor_pos_set(std::string part_, Edje_Cursor cur_, int pos_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_cursor_pos_set(efl::eolian::to_c(part_), cur_, pos_));
      }

      virtual int part_text_cursor_pos_get(std::string part_, Edje_Cursor cur_)
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_cursor_pos_get(efl::eolian::to_c(part_), cur_));
            return _tmp_ret;
      }

      virtual int freeze()
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_freeze());
            return _tmp_ret;
      }

      virtual char * part_text_cursor_content_get(std::string part_, Edje_Cursor cur_)
      {
         char * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_cursor_content_get(efl::eolian::to_c(part_), cur_));
            return _tmp_ret;
      }

      virtual void part_text_input_panel_layout_set(std::string part_, Edje_Input_Panel_Layout layout_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_input_panel_layout_set(efl::eolian::to_c(part_), layout_));
      }

      virtual Edje_Input_Panel_Layout part_text_input_panel_layout_get(std::string part_)
      {
         Edje_Input_Panel_Layout _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_input_panel_layout_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      virtual bool part_table_pack(std::string part_, evas::object child_obj_, unsigned short col_, unsigned short row_, unsigned short colspan_, unsigned short rowspan_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_table_pack(efl::eolian::to_c(part_), efl::eolian::to_c(child_obj_), col_, row_, colspan_, rowspan_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void part_text_input_panel_language_set(std::string part_, Edje_Input_Panel_Lang lang_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_input_panel_language_set(efl::eolian::to_c(part_), lang_));
      }

      virtual Edje_Input_Panel_Lang part_text_input_panel_language_get(std::string part_)
      {
         Edje_Input_Panel_Lang _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_input_panel_language_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      virtual bool part_table_col_row_size_get(std::string part_, int* cols_, int* rows_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_table_col_row_size_get(efl::eolian::to_c(part_), cols_, rows_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual evas::object part_external_object_get(std::string part_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_external_object_get(efl::eolian::to_c(part_)));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual evas::object part_external_content_get(std::string part_, const char* content_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_external_content_get(efl::eolian::to_c(part_), content_));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      virtual void part_text_input_panel_enabled_set(std::string part_, bool enabled_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_input_panel_enabled_set(efl::eolian::to_c(part_), efl::eolian::to_c(enabled_)));
      }

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

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

      virtual bool part_box_insert_at(std::string part_, evas::object child_, unsigned int pos_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_box_insert_at(efl::eolian::to_c(part_), efl::eolian::to_c(child_), pos_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual efl::eina::crange_list< const Evas_Textblock_Rectangle * > part_text_anchor_geometry_get(std::string part_, 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 = ::edje_obj_part_text_anchor_geometry_get(efl::eolian::to_c(part_), efl::eolian::to_c(anchor_)));
            return efl::eolian::to_cxx<efl::eina::crange_list< const Evas_Textblock_Rectangle * >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      virtual bool part_text_cursor_down(std::string part_, Edje_Cursor cur_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_cursor_down(efl::eolian::to_c(part_), cur_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_drag_page_set(std::string part_, double dx_, double dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_drag_page_set(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_drag_page_get(std::string part_, double* dx_, double* dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_drag_page_get(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_box_prepend(std::string part_, evas::object child_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_box_prepend(efl::eolian::to_c(part_), efl::eolian::to_c(child_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void signal_emit(std::string emission_, std::string source_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_signal_emit(efl::eolian::to_c(emission_), efl::eolian::to_c(source_)));
      }

      virtual void part_text_input_panel_layout_variation_set(std::string part_, int variation_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_input_panel_layout_variation_set(efl::eolian::to_c(part_), variation_));
      }

      virtual int part_text_input_panel_layout_variation_get(std::string part_)
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_input_panel_layout_variation_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      virtual void message_send(Edje_Message_Type type_, int id_, void * msg_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_message_send(type_, id_, msg_));
      }

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

      virtual const Evas_Object * part_object_get(std::string part_)
      {
         const Evas_Object * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_object_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      virtual bool part_drag_size_set(std::string part_, double dw_, double dh_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_drag_size_set(efl::eolian::to_c(part_), dw_, dh_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_drag_size_get(std::string part_, double* dw_, double* dh_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_drag_size_get(efl::eolian::to_c(part_), dw_, dh_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void * text_insert_filter_callback_del(std::string part_, Edje_Text_Filter_Cb func_)
      {
         void * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_text_insert_filter_callback_del(efl::eolian::to_c(part_), func_));
            return _tmp_ret;
      }

      virtual Edje_Drag_Dir part_drag_dir_get(std::string part_)
      {
         Edje_Drag_Dir _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_drag_dir_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      virtual bool part_text_unescaped_set(std::string part_, std::string text_to_escape_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_unescaped_set(efl::eolian::to_c(part_), efl::eolian::to_c(text_to_escape_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual char * part_text_unescaped_get(std::string part_)
      {
         char * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_unescaped_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      virtual void signal_callback_add(std::string emission_, std::string source_, Edje_Signal_Cb func_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_signal_callback_add(efl::eolian::to_c(emission_), efl::eolian::to_c(source_), func_, data_));
      }

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

      virtual void part_text_input_panel_return_key_disabled_set(std::string part_, bool disabled_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_input_panel_return_key_disabled_set(efl::eolian::to_c(part_), efl::eolian::to_c(disabled_)));
      }

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

      virtual void part_text_autocapital_type_set(std::string part_, Edje_Text_Autocapital_Type autocapital_type_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_autocapital_type_set(efl::eolian::to_c(part_), autocapital_type_));
      }

      virtual Edje_Text_Autocapital_Type part_text_autocapital_type_get(std::string part_)
      {
         Edje_Text_Autocapital_Type _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_autocapital_type_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      virtual void part_unswallow(evas::object obj_swallow_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_unswallow(efl::eolian::to_c(obj_swallow_)));
      }

      virtual void part_text_prediction_allow_set(std::string part_, bool prediction_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_prediction_allow_set(efl::eolian::to_c(part_), efl::eolian::to_c(prediction_)));
      }

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

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

      virtual void text_markup_filter_callback_add(std::string part_, Edje_Markup_Filter_Cb func_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_text_markup_filter_callback_add(efl::eolian::to_c(part_), func_, data_));
      }

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

      virtual evas::object part_box_remove(std::string part_, evas::object child_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_box_remove(efl::eolian::to_c(part_), efl::eolian::to_c(child_)));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual int thaw()
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_thaw());
            return _tmp_ret;
      }

      virtual evas::object part_swallow_get(std::string part_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_swallow_get(efl::eolian::to_c(part_)));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      virtual void part_text_input_panel_return_key_type_set(std::string part_, Edje_Input_Panel_Return_Key_Type return_key_type_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_input_panel_return_key_type_set(efl::eolian::to_c(part_), return_key_type_));
      }

      virtual Edje_Input_Panel_Return_Key_Type part_text_input_panel_return_key_type_get(std::string part_)
      {
         Edje_Input_Panel_Return_Key_Type _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_input_panel_return_key_type_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      virtual evas::object part_table_child_get(std::string part_, unsigned int col_, unsigned int row_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_table_child_get(efl::eolian::to_c(part_), col_, row_));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_box_insert_before(std::string part_, evas::object child_, const Evas_Object * reference_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_box_insert_before(efl::eolian::to_c(part_), efl::eolian::to_c(child_), reference_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_external_param_set(std::string part_, const Edje_External_Param * param_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_external_param_set(efl::eolian::to_c(part_), param_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_external_param_get(std::string part_, Edje_External_Param* param_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_external_param_get(efl::eolian::to_c(part_), param_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void size_min_calc(Evas_Coord* minw_, Evas_Coord* minh_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_size_min_calc(minw_, minh_));
      }

      virtual bool part_box_append(std::string part_, evas::object child_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_box_append(efl::eolian::to_c(part_), efl::eolian::to_c(child_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void size_min_restricted_calc(Evas_Coord* minw_, Evas_Coord* minh_, Evas_Coord restrictedw_, Evas_Coord restrictedh_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_size_min_restricted_calc(minw_, minh_, restrictedw_, restrictedh_));
      }

      virtual bool part_box_remove_all(std::string part_, bool clear_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_box_remove_all(efl::eolian::to_c(part_), efl::eolian::to_c(clear_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_drag_page(std::string part_, double dx_, double dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_drag_page(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_text_set(std::string part_, std::string text_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_set(efl::eolian::to_c(part_), efl::eolian::to_c(text_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      virtual void part_text_input_panel_show_on_demand_set(std::string part_, bool ondemand_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_input_panel_show_on_demand_set(efl::eolian::to_c(part_), efl::eolian::to_c(ondemand_)));
      }

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

      virtual void part_text_input_hint_set(std::string part_, Edje_Input_Hints input_hints_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_input_hint_set(efl::eolian::to_c(part_), input_hints_));
      }

      virtual Edje_Input_Hints part_text_input_hint_get(std::string part_)
      {
         Edje_Input_Hints _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_input_hint_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

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

      virtual bool part_text_cursor_is_format_get(std::string part_, Edje_Cursor cur_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_cursor_is_format_get(efl::eolian::to_c(part_), cur_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool color_class_set(std::string color_class_, int r_, int g_, int b_, int a_, int r2_, int g2_, int b2_, int a2_, int r3_, int g3_, int b3_, int a3_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_color_class_set(efl::eolian::to_c(color_class_), r_, g_, b_, a_, r2_, g2_, b2_, a2_, r3_, g3_, b3_, a3_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool color_class_get(std::string color_class_, int* r_, int* g_, int* b_, int* a_, int* r2_, int* g2_, int* b2_, int* a2_, int* r3_, int* g3_, int* b3_, int* a3_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_color_class_get(efl::eolian::to_c(color_class_), r_, g_, b_, a_, r2_, g2_, b2_, a2_, r3_, g3_, b3_, a3_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_drag_step(std::string part_, double dx_, double dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_drag_step(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool part_text_cursor_up(std::string part_, Edje_Cursor cur_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_cursor_up(efl::eolian::to_c(part_), cur_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void part_text_cursor_geometry_get(std::string part_, Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_part_text_cursor_geometry_get(efl::eolian::to_c(part_), x_, y_, w_, h_));
      }

      virtual efl::eina::crange_list< std::string > part_text_anchor_list_get(std::string part_)
      {
         const Eina_List * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_anchor_list_get(efl::eolian::to_c(part_)));
            return efl::eolian::to_cxx<efl::eina::crange_list< std::string >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      virtual void text_insert_filter_callback_add(std::string part_, Edje_Text_Filter_Cb func_, void * data_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::edje_obj_text_insert_filter_callback_add(efl::eolian::to_c(part_), func_, data_));
      }

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

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

      virtual void * text_markup_filter_callback_del(std::string part_, Edje_Markup_Filter_Cb func_)
      {
         void * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_text_markup_filter_callback_del(efl::eolian::to_c(part_), func_));
            return _tmp_ret;
      }

      virtual bool part_text_cursor_is_visible_format_get(std::string part_, Edje_Cursor cur_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_cursor_is_visible_format_get(efl::eolian::to_c(part_), cur_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      virtual bool part_text_cursor_prev(std::string part_, Edje_Cursor cur_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_cursor_prev(efl::eolian::to_c(part_), cur_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual efl::eina::crange_list< std::string > part_text_item_list_get(std::string part_)
      {
         const Eina_List * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_text_item_list_get(efl::eolian::to_c(part_)));
            return efl::eolian::to_cxx<efl::eina::crange_list< std::string >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      virtual bool part_swallow(std::string part_, evas::object obj_swallow_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::edje_obj_part_swallow(efl::eolian::to_c(part_), efl::eolian::to_c(obj_swallow_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

   };
};


template<>
struct operation_description_class_size< edje::object >
{
   static const int value = 152;
};

template <typename T>
int initialize_operation_description(efl::eo::detail::tag<edje::object>
                                 , Eo_Op_Description* ops)
{
   (void)ops;
   ops[0].func = reinterpret_cast<void*>(& ::edje_object_dbg_info_get_wrapper<T>);
   ops[0].api_func = reinterpret_cast<void*>(& ::eo_dbg_info_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*>(& ::edje_object_hide_wrapper<T>);
   ops[1].api_func = reinterpret_cast<void*>(& ::evas_obj_smart_hide);
   ops[1].op = EO_OP_OVERRIDE;
   ops[1].op_type = EO_OP_TYPE_REGULAR;
   ops[1].doc = NULL;

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

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

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

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

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

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

   ops[8].func = reinterpret_cast<void*>(& ::edje_object_file_set_wrapper<T>);
   ops[8].api_func = reinterpret_cast<void*>(& ::efl_file_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*>(& ::edje_object_file_get_wrapper<T>);
   ops[9].api_func = reinterpret_cast<void*>(& ::efl_file_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*>(& ::edje_object_update_hints_get_wrapper<T>);
   ops[10].api_func = reinterpret_cast<void*>(& ::edje_obj_update_hints_get);
   ops[10].op = EO_OP_OVERRIDE;
   ops[10].op_type = EO_OP_TYPE_REGULAR;
   ops[10].doc = NULL;

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

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

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

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

   ops[15].func = reinterpret_cast<void*>(& ::edje_object_animation_set_wrapper<T>);
   ops[15].api_func = reinterpret_cast<void*>(& ::edje_obj_animation_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*>(& ::edje_object_play_get_wrapper<T>);
   ops[16].api_func = reinterpret_cast<void*>(& ::edje_obj_play_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*>(& ::edje_object_play_set_wrapper<T>);
   ops[17].api_func = reinterpret_cast<void*>(& ::edje_obj_play_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*>(& ::edje_object_perspective_get_wrapper<T>);
   ops[18].api_func = reinterpret_cast<void*>(& ::edje_obj_perspective_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*>(& ::edje_object_perspective_set_wrapper<T>);
   ops[19].api_func = reinterpret_cast<void*>(& ::edje_obj_perspective_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*>(& ::edje_object_scale_get_wrapper<T>);
   ops[20].api_func = reinterpret_cast<void*>(& ::edje_obj_scale_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*>(& ::edje_object_scale_set_wrapper<T>);
   ops[21].api_func = reinterpret_cast<void*>(& ::edje_obj_scale_set);
   ops[21].op = EO_OP_OVERRIDE;
   ops[21].op_type = EO_OP_TYPE_REGULAR;
   ops[21].doc = NULL;

   ops[22].func = reinterpret_cast<void*>(& ::edje_object_base_scale_get_wrapper<T>);
   ops[22].api_func = reinterpret_cast<void*>(& ::edje_obj_base_scale_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*>(& ::edje_object_mmap_set_wrapper<T>);
   ops[23].api_func = reinterpret_cast<void*>(& ::edje_obj_mmap_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*>(& ::edje_object_text_change_cb_set_wrapper<T>);
   ops[24].api_func = reinterpret_cast<void*>(& ::edje_obj_text_change_cb_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*>(& ::edje_object_part_text_cursor_begin_set_wrapper<T>);
   ops[25].api_func = reinterpret_cast<void*>(& ::edje_obj_part_text_cursor_begin_set);
   ops[25].op = EO_OP_OVERRIDE;
   ops[25].op_type = EO_OP_TYPE_REGULAR;
   ops[25].doc = NULL;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      void dbg_info_get(Eo_Dbg_Info * root_node_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::eo_dbg_info_get(root_node_));
      }

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

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

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

      void move(Evas_Coord x_, Evas_Coord y_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_obj_smart_move(x_, y_));
      }

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

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

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

      bool file_set(std::string file_, std::string key_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::efl_file_set(efl::eolian::to_c(file_), efl::eolian::to_c(key_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void file_get(const char ** file_, const char ** key_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::efl_file_get(file_, key_));
      }

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

      void update_hints_set(bool update_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_update_hints_set(efl::eolian::to_c(update_)));
      }

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

      void mirrored_set(bool rtl_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_mirrored_set(efl::eolian::to_c(rtl_)));
      }

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

      void animation_set(bool on_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_animation_set(efl::eolian::to_c(on_)));
      }

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

      void play_set(bool play_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_play_set(efl::eolian::to_c(play_)));
      }

      const Edje_Perspective * perspective_get()
      {
         const Edje_Perspective * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_perspective_get());
            return _tmp_ret;
      }

      void perspective_set(Edje_Perspective * ps_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_perspective_set(ps_));
      }

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

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

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

      bool mmap_set(const Eina_File * file_, std::string group_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_mmap_set(file_, efl::eolian::to_c(group_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void text_change_cb_set(Edje_Text_Change_Cb func_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_text_change_cb_set(func_, data_));
      }

      void part_text_cursor_begin_set(std::string part_, Edje_Cursor cur_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_cursor_begin_set(efl::eolian::to_c(part_), cur_));
      }

      void part_text_cursor_line_end_set(std::string part_, Edje_Cursor cur_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_cursor_line_end_set(efl::eolian::to_c(part_), cur_));
      }

      bool text_class_set(std::string text_class_, std::string font_, Evas_Font_Size size_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_text_class_set(efl::eolian::to_c(text_class_), efl::eolian::to_c(font_), size_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_text_cursor_coord_set(std::string part_, Edje_Cursor cur_, Evas_Coord x_, Evas_Coord y_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_coord_set(efl::eolian::to_c(part_), cur_, x_, y_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void part_text_cursor_end_set(std::string part_, Edje_Cursor cur_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_cursor_end_set(efl::eolian::to_c(part_), cur_));
      }

      bool part_text_escaped_set(std::string part_, std::string text_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_escaped_set(efl::eolian::to_c(part_), efl::eolian::to_c(text_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void item_provider_set(Edje_Item_Provider_Cb func_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_item_provider_set(func_, data_));
      }

      void part_text_cursor_line_begin_set(std::string part_, Edje_Cursor cur_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_cursor_line_begin_set(efl::eolian::to_c(part_), cur_));
      }

      void message_handler_set(Edje_Message_Handler_Cb func_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_message_handler_set(func_, data_));
      }

      void size_min_get(Evas_Coord* minw_, Evas_Coord* minh_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_size_min_get(minw_, minh_));
      }

      efl::eina::range_list< std::string > access_part_list_get()
      {
         Eina_List * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_access_part_list_get());
            return efl::eolian::to_cxx<efl::eina::range_list< std::string >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      Edje_Load_Error load_error_get()
      {
         Edje_Load_Error _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_load_error_get());
            return _tmp_ret;
      }

      void size_max_get(Evas_Coord* maxw_, Evas_Coord* maxh_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_size_max_get(maxw_, maxh_));
      }

      bool part_table_clear(std::string part_, bool clear_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_table_clear(efl::eolian::to_c(part_), efl::eolian::to_c(clear_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      Edje_External_Param_Type part_external_param_type_get(std::string part_, const char* param_)
      {
         Edje_External_Param_Type _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_external_param_type_get(efl::eolian::to_c(part_), param_));
            return _tmp_ret;
      }

      void part_text_select_allow_set(std::string part_, bool allow_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_select_allow_set(efl::eolian::to_c(part_), efl::eolian::to_c(allow_)));
      }

      std::string part_state_get(std::string part_, double* val_ret_)
      {
         const char * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_state_get(efl::eolian::to_c(part_), val_ret_));
            return efl::eolian::to_cxx<std::string>(_tmp_ret, std::tuple<std::false_type>());
      }

      void * text_markup_filter_callback_del_full(std::string part_, Edje_Markup_Filter_Cb func_, void * data_)
      {
         void * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_text_markup_filter_callback_del_full(efl::eolian::to_c(part_), func_, data_));
            return _tmp_ret;
      }

      bool part_drag_step_set(std::string part_, double dx_, double dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_step_set(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_drag_step_get(std::string part_, double* dx_, double* dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_step_get(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void * part_text_imf_context_get(std::string part_)
      {
         void * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_imf_context_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      void part_text_select_begin(std::string part_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_select_begin(efl::eolian::to_c(part_)));
      }

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

      void * signal_callback_del(std::string emission_, std::string source_, Edje_Signal_Cb func_, void * data_)
      {
         void * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_signal_callback_del(efl::eolian::to_c(emission_), efl::eolian::to_c(source_), func_, data_));
            return _tmp_ret;
      }

      bool part_text_cursor_next(std::string part_, Edje_Cursor cur_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_next(efl::eolian::to_c(part_), cur_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void part_text_style_user_push(std::string part_, std::string style_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_style_user_push(efl::eolian::to_c(part_), efl::eolian::to_c(style_)));
      }

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

      bool part_geometry_get(std::string part_, Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_geometry_get(efl::eolian::to_c(part_), x_, y_, w_, h_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void part_text_input_panel_hide(std::string part_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_input_panel_hide(efl::eolian::to_c(part_)));
      }

      bool part_text_item_geometry_get(std::string part_, std::string item_, 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 = ::edje_obj_part_text_item_geometry_get(efl::eolian::to_c(part_), efl::eolian::to_c(item_), cx_, cy_, cw_, ch_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_table_unpack(std::string part_, evas::object child_obj_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_table_unpack(efl::eolian::to_c(part_), efl::eolian::to_c(child_obj_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void part_text_select_abort(std::string part_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_select_abort(efl::eolian::to_c(part_)));
      }

      void * text_insert_filter_callback_del_full(std::string part_, Edje_Text_Filter_Cb func_, void * data_)
      {
         void * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_text_insert_filter_callback_del_full(efl::eolian::to_c(part_), func_, data_));
            return _tmp_ret;
      }

      void part_text_style_user_pop(std::string part_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_style_user_pop(efl::eolian::to_c(part_)));
      }

      void part_text_input_panel_imdata_set(std::string part_, const void * data_, int len_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_input_panel_imdata_set(efl::eolian::to_c(part_), data_, len_));
      }

      void part_text_input_panel_imdata_get(std::string part_, void * data_, int * len_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_input_panel_imdata_get(efl::eolian::to_c(part_), data_, len_));
      }

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

      evas::object part_box_remove_at(std::string part_, unsigned int pos_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_box_remove_at(efl::eolian::to_c(part_), pos_));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      void part_text_cursor_copy(std::string part_, Edje_Cursor src_, Edje_Cursor dst_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_cursor_copy(efl::eolian::to_c(part_), src_, dst_));
      }

      bool parts_extends_calc(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_parts_extends_calc(x_, y_, w_, h_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_drag_value_set(std::string part_, double dx_, double dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_value_set(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_drag_value_get(std::string part_, double* dx_, double* dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_value_get(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      void part_text_cursor_pos_set(std::string part_, Edje_Cursor cur_, int pos_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_cursor_pos_set(efl::eolian::to_c(part_), cur_, pos_));
      }

      int part_text_cursor_pos_get(std::string part_, Edje_Cursor cur_)
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_pos_get(efl::eolian::to_c(part_), cur_));
            return _tmp_ret;
      }

      int freeze()
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_freeze());
            return _tmp_ret;
      }

      char * part_text_cursor_content_get(std::string part_, Edje_Cursor cur_)
      {
         char * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_content_get(efl::eolian::to_c(part_), cur_));
            return _tmp_ret;
      }

      void part_text_input_panel_layout_set(std::string part_, Edje_Input_Panel_Layout layout_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_input_panel_layout_set(efl::eolian::to_c(part_), layout_));
      }

      Edje_Input_Panel_Layout part_text_input_panel_layout_get(std::string part_)
      {
         Edje_Input_Panel_Layout _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_panel_layout_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      bool part_table_pack(std::string part_, evas::object child_obj_, unsigned short col_, unsigned short row_, unsigned short colspan_, unsigned short rowspan_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_table_pack(efl::eolian::to_c(part_), efl::eolian::to_c(child_obj_), col_, row_, colspan_, rowspan_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void part_text_input_panel_language_set(std::string part_, Edje_Input_Panel_Lang lang_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_input_panel_language_set(efl::eolian::to_c(part_), lang_));
      }

      Edje_Input_Panel_Lang part_text_input_panel_language_get(std::string part_)
      {
         Edje_Input_Panel_Lang _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_panel_language_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      bool part_table_col_row_size_get(std::string part_, int* cols_, int* rows_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_table_col_row_size_get(efl::eolian::to_c(part_), cols_, rows_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      evas::object part_external_object_get(std::string part_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_external_object_get(efl::eolian::to_c(part_)));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      evas::object part_external_content_get(std::string part_, const char* content_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_external_content_get(efl::eolian::to_c(part_), content_));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      void part_text_input_panel_enabled_set(std::string part_, bool enabled_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_input_panel_enabled_set(efl::eolian::to_c(part_), efl::eolian::to_c(enabled_)));
      }

      bool part_text_input_panel_enabled_get(std::string part_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_panel_enabled_get(efl::eolian::to_c(part_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void part_text_select_extend(std::string part_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_select_extend(efl::eolian::to_c(part_)));
      }

      bool part_box_insert_at(std::string part_, evas::object child_, unsigned int pos_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_box_insert_at(efl::eolian::to_c(part_), efl::eolian::to_c(child_), pos_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      efl::eina::crange_list< const Evas_Textblock_Rectangle * > part_text_anchor_geometry_get(std::string part_, std::string anchor_)
      {
         const Eina_List * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_anchor_geometry_get(efl::eolian::to_c(part_), efl::eolian::to_c(anchor_)));
            return efl::eolian::to_cxx<efl::eina::crange_list< const Evas_Textblock_Rectangle * >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      bool part_text_cursor_down(std::string part_, Edje_Cursor cur_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_down(efl::eolian::to_c(part_), cur_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_drag_page_set(std::string part_, double dx_, double dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_page_set(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_drag_page_get(std::string part_, double* dx_, double* dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_page_get(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_box_prepend(std::string part_, evas::object child_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_box_prepend(efl::eolian::to_c(part_), efl::eolian::to_c(child_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void signal_emit(std::string emission_, std::string source_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_signal_emit(efl::eolian::to_c(emission_), efl::eolian::to_c(source_)));
      }

      void part_text_input_panel_layout_variation_set(std::string part_, int variation_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_input_panel_layout_variation_set(efl::eolian::to_c(part_), variation_));
      }

      int part_text_input_panel_layout_variation_get(std::string part_)
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_panel_layout_variation_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      void message_send(Edje_Message_Type type_, int id_, void * msg_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_message_send(type_, id_, msg_));
      }

      void part_text_select_none(std::string part_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_select_none(efl::eolian::to_c(part_)));
      }

      const Evas_Object * part_object_get(std::string part_)
      {
         const Evas_Object * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_object_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      bool part_drag_size_set(std::string part_, double dw_, double dh_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_size_set(efl::eolian::to_c(part_), dw_, dh_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_drag_size_get(std::string part_, double* dw_, double* dh_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_size_get(efl::eolian::to_c(part_), dw_, dh_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void * text_insert_filter_callback_del(std::string part_, Edje_Text_Filter_Cb func_)
      {
         void * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_text_insert_filter_callback_del(efl::eolian::to_c(part_), func_));
            return _tmp_ret;
      }

      Edje_Drag_Dir part_drag_dir_get(std::string part_)
      {
         Edje_Drag_Dir _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_dir_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      bool part_text_unescaped_set(std::string part_, std::string text_to_escape_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_unescaped_set(efl::eolian::to_c(part_), efl::eolian::to_c(text_to_escape_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      char * part_text_unescaped_get(std::string part_)
      {
         char * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_unescaped_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      void signal_callback_add(std::string emission_, std::string source_, Edje_Signal_Cb func_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_signal_callback_add(efl::eolian::to_c(emission_), efl::eolian::to_c(source_), func_, data_));
      }

      void part_text_select_all(std::string part_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_select_all(efl::eolian::to_c(part_)));
      }

      void part_text_input_panel_return_key_disabled_set(std::string part_, bool disabled_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_input_panel_return_key_disabled_set(efl::eolian::to_c(part_), efl::eolian::to_c(disabled_)));
      }

      bool part_text_input_panel_return_key_disabled_get(std::string part_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_panel_return_key_disabled_get(efl::eolian::to_c(part_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void part_text_autocapital_type_set(std::string part_, Edje_Text_Autocapital_Type autocapital_type_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_autocapital_type_set(efl::eolian::to_c(part_), autocapital_type_));
      }

      Edje_Text_Autocapital_Type part_text_autocapital_type_get(std::string part_)
      {
         Edje_Text_Autocapital_Type _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_autocapital_type_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      void part_unswallow(evas::object obj_swallow_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_unswallow(efl::eolian::to_c(obj_swallow_)));
      }

      void part_text_prediction_allow_set(std::string part_, bool prediction_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_prediction_allow_set(efl::eolian::to_c(part_), efl::eolian::to_c(prediction_)));
      }

      bool part_text_prediction_allow_get(std::string part_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_prediction_allow_get(efl::eolian::to_c(part_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      void text_markup_filter_callback_add(std::string part_, Edje_Markup_Filter_Cb func_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_text_markup_filter_callback_add(efl::eolian::to_c(part_), func_, data_));
      }

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

      evas::object part_box_remove(std::string part_, evas::object child_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_box_remove(efl::eolian::to_c(part_), efl::eolian::to_c(child_)));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      int thaw()
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_thaw());
            return _tmp_ret;
      }

      evas::object part_swallow_get(std::string part_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_swallow_get(efl::eolian::to_c(part_)));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      void part_text_imf_context_reset(std::string part_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_imf_context_reset(efl::eolian::to_c(part_)));
      }

      void part_text_input_panel_return_key_type_set(std::string part_, Edje_Input_Panel_Return_Key_Type return_key_type_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_input_panel_return_key_type_set(efl::eolian::to_c(part_), return_key_type_));
      }

      Edje_Input_Panel_Return_Key_Type part_text_input_panel_return_key_type_get(std::string part_)
      {
         Edje_Input_Panel_Return_Key_Type _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_panel_return_key_type_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

      evas::object part_table_child_get(std::string part_, unsigned int col_, unsigned int row_)
      {
         Evas_Object * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_table_child_get(efl::eolian::to_c(part_), col_, row_));
            return efl::eolian::to_cxx<evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_box_insert_before(std::string part_, evas::object child_, const Evas_Object * reference_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_box_insert_before(efl::eolian::to_c(part_), efl::eolian::to_c(child_), reference_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_external_param_set(std::string part_, const Edje_External_Param * param_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_external_param_set(efl::eolian::to_c(part_), param_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_external_param_get(std::string part_, Edje_External_Param* param_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_external_param_get(efl::eolian::to_c(part_), param_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void size_min_calc(Evas_Coord* minw_, Evas_Coord* minh_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_size_min_calc(minw_, minh_));
      }

      bool part_box_append(std::string part_, evas::object child_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_box_append(efl::eolian::to_c(part_), efl::eolian::to_c(child_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void size_min_restricted_calc(Evas_Coord* minw_, Evas_Coord* minh_, Evas_Coord restrictedw_, Evas_Coord restrictedh_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_size_min_restricted_calc(minw_, minh_, restrictedw_, restrictedh_));
      }

      bool part_box_remove_all(std::string part_, bool clear_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_box_remove_all(efl::eolian::to_c(part_), efl::eolian::to_c(clear_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_drag_page(std::string part_, double dx_, double dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_page(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_text_set(std::string part_, std::string text_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_set(efl::eolian::to_c(part_), efl::eolian::to_c(text_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      void part_text_input_panel_show_on_demand_set(std::string part_, bool ondemand_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_input_panel_show_on_demand_set(efl::eolian::to_c(part_), efl::eolian::to_c(ondemand_)));
      }

      bool part_text_input_panel_show_on_demand_get(std::string part_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_panel_show_on_demand_get(efl::eolian::to_c(part_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void part_text_input_hint_set(std::string part_, Edje_Input_Hints input_hints_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_input_hint_set(efl::eolian::to_c(part_), input_hints_));
      }

      Edje_Input_Hints part_text_input_hint_get(std::string part_)
      {
         Edje_Input_Hints _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_input_hint_get(efl::eolian::to_c(part_)));
            return _tmp_ret;
      }

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

      bool part_text_cursor_is_format_get(std::string part_, Edje_Cursor cur_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_is_format_get(efl::eolian::to_c(part_), cur_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool color_class_set(std::string color_class_, int r_, int g_, int b_, int a_, int r2_, int g2_, int b2_, int a2_, int r3_, int g3_, int b3_, int a3_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_color_class_set(efl::eolian::to_c(color_class_), r_, g_, b_, a_, r2_, g2_, b2_, a2_, r3_, g3_, b3_, a3_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool color_class_get(std::string color_class_, int* r_, int* g_, int* b_, int* a_, int* r2_, int* g2_, int* b2_, int* a2_, int* r3_, int* g3_, int* b3_, int* a3_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_color_class_get(efl::eolian::to_c(color_class_), r_, g_, b_, a_, r2_, g2_, b2_, a2_, r3_, g3_, b3_, a3_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_drag_step(std::string part_, double dx_, double dy_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_drag_step(efl::eolian::to_c(part_), dx_, dy_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      bool part_text_cursor_up(std::string part_, Edje_Cursor cur_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_up(efl::eolian::to_c(part_), cur_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void part_text_cursor_geometry_get(std::string part_, Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_cursor_geometry_get(efl::eolian::to_c(part_), x_, y_, w_, h_));
      }

      efl::eina::crange_list< std::string > part_text_anchor_list_get(std::string part_)
      {
         const Eina_List * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_anchor_list_get(efl::eolian::to_c(part_)));
            return efl::eolian::to_cxx<efl::eina::crange_list< std::string >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      void text_insert_filter_callback_add(std::string part_, Edje_Text_Filter_Cb func_, void * data_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_text_insert_filter_callback_add(efl::eolian::to_c(part_), func_, data_));
      }

      void part_text_input_panel_show(std::string part_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::edje_obj_part_text_input_panel_show(efl::eolian::to_c(part_)));
      }

      bool part_exists(std::string part_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_exists(efl::eolian::to_c(part_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void * text_markup_filter_callback_del(std::string part_, Edje_Markup_Filter_Cb func_)
      {
         void * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_text_markup_filter_callback_del(efl::eolian::to_c(part_), func_));
            return _tmp_ret;
      }

      bool part_text_cursor_is_visible_format_get(std::string part_, Edje_Cursor cur_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_is_visible_format_get(efl::eolian::to_c(part_), cur_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

      bool part_text_cursor_prev(std::string part_, Edje_Cursor cur_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_cursor_prev(efl::eolian::to_c(part_), cur_));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      efl::eina::crange_list< std::string > part_text_item_list_get(std::string part_)
      {
         const Eina_List * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_text_item_list_get(efl::eolian::to_c(part_)));
            return efl::eolian::to_cxx<efl::eina::crange_list< std::string >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      bool part_swallow(std::string part_, evas::object obj_swallow_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::edje_obj_part_swallow(efl::eolian::to_c(part_), efl::eolian::to_c(obj_swallow_)));
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

   };
};

inline Eo_Class const* get_eo_class(tag<edje::object>)
{
   return (EDJE_OBJECT_CLASS);
}

} } }
#endif // EFL_GENERATED_EDJE_OBJECT_HH

