/// @cond EO_CXX_EO_IMPL

inline ::elm::widget_item elm::gengrid::item_insert_before(const Elm_Gengrid_Item_Class * itc_, const void * data_, ::elm::widget_item relative_, Evas_Smart_Cb func_, const void * func_data_) const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_item_insert_before(itc_, data_, ::efl::eolian::to_c(relative_), func_, func_data_));
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::gengrid::realized_items_update() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_realized_items_update());
}

inline ::elm::widget_item elm::gengrid::item_insert_after(const Elm_Gengrid_Item_Class * itc_, const void * data_, ::elm::widget_item relative_, Evas_Smart_Cb func_, const void * func_data_) const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_item_insert_after(itc_, data_, ::efl::eolian::to_c(relative_), func_, func_data_));
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline unsigned int elm::gengrid::items_count() const
{
   unsigned int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_items_count());
   return _tmp_ret;
}

inline ::elm::widget_item elm::gengrid::at_xy_item_get(Evas_Coord x_, Evas_Coord y_, int* xposret_, int* yposret_) const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_at_xy_item_get(x_, y_, xposret_, yposret_));
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::elm::widget_item elm::gengrid::item_append(const Elm_Gengrid_Item_Class * itc_, const void * data_, Evas_Smart_Cb func_, const void * func_data_) const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_item_append(itc_, data_, func_, func_data_));
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::elm::widget_item elm::gengrid::item_prepend(const Elm_Gengrid_Item_Class * itc_, const void * data_, Evas_Smart_Cb func_, const void * func_data_) const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_item_prepend(itc_, data_, func_, func_data_));
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::gengrid::clear() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_clear());
}

inline ::elm::widget_item elm::gengrid::item_sorted_insert(const Elm_Gengrid_Item_Class * itc_, const void * data_, Eina_Compare_Cb comp_, Evas_Smart_Cb func_, const void * func_data_) const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_item_sorted_insert(itc_, data_, comp_, func_, func_data_));
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::elm::widget_item elm::gengrid::search_by_text_item_get(::elm::widget_item item_to_search_from_, ::efl::eina::string_view part_name_, ::efl::eina::string_view pattern_, Elm_Glob_Match_Flags flags_) const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_search_by_text_item_get(::efl::eolian::to_c(item_to_search_from_), ::efl::eolian::to_c(part_name_), ::efl::eolian::to_c(pattern_), flags_));
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::gengrid::reorder_mode_start(Ecore_Pos_Map tween_mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_reorder_mode_start(tween_mode_));
}

inline void elm::gengrid::reorder_mode_stop() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_reorder_mode_stop());
}

inline void elm::gengrid::align_get(double* align_x_, double* align_y_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_align_get(align_x_, align_y_));
}

inline void elm::gengrid::align_set(double align_x_, double align_y_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_align_set(align_x_, align_y_));
}

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

inline void elm::gengrid::filled_set(bool fill_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_filled_set(::efl::eolian::to_c(fill_)));
}

inline void elm::gengrid::page_relative_get(double* h_pagerel_, double* v_pagerel_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_page_relative_get(h_pagerel_, v_pagerel_));
}

inline void elm::gengrid::page_relative_set(double h_pagerel_, double v_pagerel_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_page_relative_set(h_pagerel_, v_pagerel_));
}

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

inline void elm::gengrid::multi_select_set(bool multi_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_multi_select_set(::efl::eolian::to_c(multi_)));
}

inline void elm::gengrid::group_item_size_get(Evas_Coord* w_, Evas_Coord* h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_group_item_size_get(w_, h_));
}

inline void elm::gengrid::group_item_size_set(Evas_Coord w_, Evas_Coord h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_group_item_size_set(w_, h_));
}

inline Elm_Object_Select_Mode elm::gengrid::select_mode_get() const
{
   Elm_Object_Select_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_select_mode_get());
   return _tmp_ret;
}

inline void elm::gengrid::select_mode_set(Elm_Object_Select_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_select_mode_set(mode_));
}

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

inline void elm::gengrid::reorder_mode_set(bool reorder_mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_reorder_mode_set(::efl::eolian::to_c(reorder_mode_)));
}

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

inline void elm::gengrid::highlight_mode_set(bool highlight_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_highlight_mode_set(::efl::eolian::to_c(highlight_)));
}

inline void elm::gengrid::reorder_type_set(Elm_Gengrid_Reorder_Type type_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_reorder_type_set(type_));
}

inline void elm::gengrid::item_size_get(Evas_Coord* w_, Evas_Coord* h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_item_size_get(w_, h_));
}

inline void elm::gengrid::item_size_set(Evas_Coord w_, Evas_Coord h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_item_size_set(w_, h_));
}

inline Elm_Object_Multi_Select_Mode elm::gengrid::multi_select_mode_get() const
{
   Elm_Object_Multi_Select_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_multi_select_mode_get());
   return _tmp_ret;
}

inline void elm::gengrid::multi_select_mode_set(Elm_Object_Multi_Select_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_multi_select_mode_set(mode_));
}

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

inline void elm::gengrid::horizontal_set(bool horizontal_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_horizontal_set(::efl::eolian::to_c(horizontal_)));
}

inline void elm::gengrid::page_size_set(Evas_Coord h_pagesize_, Evas_Coord v_pagesize_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_page_size_set(h_pagesize_, v_pagesize_));
}

inline ::elm::widget_item elm::gengrid::selected_item_get() const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_selected_item_get());
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::efl::eina::list< Elm_Gen_Item * > elm::gengrid::realized_items_get() const
{
   Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_realized_items_get());
   return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Gen_Item * >>(_tmp_ret, std::tuple<std::true_type, std::false_type>());
}

inline ::elm::widget_item elm::gengrid::first_item_get() const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_first_item_get());
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::efl::eina::crange_list< ::elm::widget_item > elm::gengrid::selected_items_get() const
{
   const Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_selected_items_get());
   return ::efl::eolian::to_cxx<::efl::eina::crange_list< ::elm::widget_item >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
}

inline ::elm::widget_item elm::gengrid::last_item_get() const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_last_item_get());
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline void elm::gengrid::wheel_disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_wheel_disabled_set(::efl::eolian::to_c(disabled_)));
}

inline ::elm::widget_item eo_cxx::elm::gengrid::item_insert_before(const Elm_Gengrid_Item_Class * itc_, const void * data_, ::elm::widget_item relative_, Evas_Smart_Cb func_, const void * func_data_) const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_item_insert_before(itc_, data_, ::efl::eolian::to_c(relative_), func_, func_data_));
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::gengrid::realized_items_update() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_realized_items_update());
}

inline ::elm::widget_item eo_cxx::elm::gengrid::item_insert_after(const Elm_Gengrid_Item_Class * itc_, const void * data_, ::elm::widget_item relative_, Evas_Smart_Cb func_, const void * func_data_) const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_item_insert_after(itc_, data_, ::efl::eolian::to_c(relative_), func_, func_data_));
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline unsigned int eo_cxx::elm::gengrid::items_count() const
{
   unsigned int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_items_count());
   return _tmp_ret;
}

inline ::elm::widget_item eo_cxx::elm::gengrid::at_xy_item_get(Evas_Coord x_, Evas_Coord y_, int* xposret_, int* yposret_) const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_at_xy_item_get(x_, y_, xposret_, yposret_));
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::elm::widget_item eo_cxx::elm::gengrid::item_append(const Elm_Gengrid_Item_Class * itc_, const void * data_, Evas_Smart_Cb func_, const void * func_data_) const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_item_append(itc_, data_, func_, func_data_));
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::elm::widget_item eo_cxx::elm::gengrid::item_prepend(const Elm_Gengrid_Item_Class * itc_, const void * data_, Evas_Smart_Cb func_, const void * func_data_) const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_item_prepend(itc_, data_, func_, func_data_));
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::gengrid::clear() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_clear());
}

inline ::elm::widget_item eo_cxx::elm::gengrid::item_sorted_insert(const Elm_Gengrid_Item_Class * itc_, const void * data_, Eina_Compare_Cb comp_, Evas_Smart_Cb func_, const void * func_data_) const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_item_sorted_insert(itc_, data_, comp_, func_, func_data_));
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::elm::widget_item eo_cxx::elm::gengrid::search_by_text_item_get(::elm::widget_item item_to_search_from_, ::efl::eina::string_view part_name_, ::efl::eina::string_view pattern_, Elm_Glob_Match_Flags flags_) const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_search_by_text_item_get(::efl::eolian::to_c(item_to_search_from_), ::efl::eolian::to_c(part_name_), ::efl::eolian::to_c(pattern_), flags_));
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::gengrid::reorder_mode_start(Ecore_Pos_Map tween_mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_reorder_mode_start(tween_mode_));
}

inline void eo_cxx::elm::gengrid::reorder_mode_stop() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_reorder_mode_stop());
}

inline void eo_cxx::elm::gengrid::align_get(double* align_x_, double* align_y_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_align_get(align_x_, align_y_));
}

inline void eo_cxx::elm::gengrid::align_set(double align_x_, double align_y_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_align_set(align_x_, align_y_));
}

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

inline void eo_cxx::elm::gengrid::filled_set(bool fill_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_filled_set(::efl::eolian::to_c(fill_)));
}

inline void eo_cxx::elm::gengrid::page_relative_get(double* h_pagerel_, double* v_pagerel_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_page_relative_get(h_pagerel_, v_pagerel_));
}

inline void eo_cxx::elm::gengrid::page_relative_set(double h_pagerel_, double v_pagerel_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_page_relative_set(h_pagerel_, v_pagerel_));
}

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

inline void eo_cxx::elm::gengrid::multi_select_set(bool multi_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_multi_select_set(::efl::eolian::to_c(multi_)));
}

inline void eo_cxx::elm::gengrid::group_item_size_get(Evas_Coord* w_, Evas_Coord* h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_group_item_size_get(w_, h_));
}

inline void eo_cxx::elm::gengrid::group_item_size_set(Evas_Coord w_, Evas_Coord h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_group_item_size_set(w_, h_));
}

inline Elm_Object_Select_Mode eo_cxx::elm::gengrid::select_mode_get() const
{
   Elm_Object_Select_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_select_mode_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::gengrid::select_mode_set(Elm_Object_Select_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_select_mode_set(mode_));
}

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

inline void eo_cxx::elm::gengrid::reorder_mode_set(bool reorder_mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_reorder_mode_set(::efl::eolian::to_c(reorder_mode_)));
}

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

inline void eo_cxx::elm::gengrid::highlight_mode_set(bool highlight_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_highlight_mode_set(::efl::eolian::to_c(highlight_)));
}

inline void eo_cxx::elm::gengrid::reorder_type_set(Elm_Gengrid_Reorder_Type type_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_reorder_type_set(type_));
}

inline void eo_cxx::elm::gengrid::item_size_get(Evas_Coord* w_, Evas_Coord* h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_item_size_get(w_, h_));
}

inline void eo_cxx::elm::gengrid::item_size_set(Evas_Coord w_, Evas_Coord h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_item_size_set(w_, h_));
}

inline Elm_Object_Multi_Select_Mode eo_cxx::elm::gengrid::multi_select_mode_get() const
{
   Elm_Object_Multi_Select_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_multi_select_mode_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::gengrid::multi_select_mode_set(Elm_Object_Multi_Select_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_multi_select_mode_set(mode_));
}

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

inline void eo_cxx::elm::gengrid::horizontal_set(bool horizontal_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_horizontal_set(::efl::eolian::to_c(horizontal_)));
}

inline void eo_cxx::elm::gengrid::page_size_set(Evas_Coord h_pagesize_, Evas_Coord v_pagesize_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_page_size_set(h_pagesize_, v_pagesize_));
}

inline ::elm::widget_item eo_cxx::elm::gengrid::selected_item_get() const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_selected_item_get());
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::efl::eina::list< Elm_Gen_Item * > eo_cxx::elm::gengrid::realized_items_get() const
{
   Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_realized_items_get());
   return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Gen_Item * >>(_tmp_ret, std::tuple<std::true_type, std::false_type>());
}

inline ::elm::widget_item eo_cxx::elm::gengrid::first_item_get() const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_first_item_get());
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::efl::eina::crange_list< ::elm::widget_item > eo_cxx::elm::gengrid::selected_items_get() const
{
   const Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_selected_items_get());
   return ::efl::eolian::to_cxx<::efl::eina::crange_list< ::elm::widget_item >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
}

inline ::elm::widget_item eo_cxx::elm::gengrid::last_item_get() const
{
   Elm_Widget_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_gengrid_last_item_get());
   return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline void eo_cxx::elm::gengrid::wheel_disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_gengrid_wheel_disabled_set(::efl::eolian::to_c(disabled_)));
}

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

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

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

template <typename T>
::elm::widget_item elm_gengrid_item_insert_before_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const Elm_Gengrid_Item_Class * itc_, const void * data_, Elm_Widget_Item * relative_, Evas_Smart_Cb func_, const void * func_data_)
{
   try
      {
         return static_cast<T*>(self->this_)->item_insert_before(itc_, data_, ::efl::eolian::to_cxx<::elm::widget_item>(relative_, std::tuple<std::false_type>()), func_, func_data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Widget_Item * _tmp_ret{};
         return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }
}

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

template <typename T>
::elm::widget_item elm_gengrid_item_insert_after_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const Elm_Gengrid_Item_Class * itc_, const void * data_, Elm_Widget_Item * relative_, Evas_Smart_Cb func_, const void * func_data_)
{
   try
      {
         return static_cast<T*>(self->this_)->item_insert_after(itc_, data_, ::efl::eolian::to_cxx<::elm::widget_item>(relative_, std::tuple<std::false_type>()), func_, func_data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Widget_Item * _tmp_ret{};
         return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }
}

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

template <typename T>
::elm::widget_item elm_gengrid_at_xy_item_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Coord x_, Evas_Coord y_, int* xposret_, int* yposret_)
{
   try
      {
         return static_cast<T*>(self->this_)->at_xy_item_get(x_, y_, xposret_, yposret_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Widget_Item * _tmp_ret{};
         return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
::elm::widget_item elm_gengrid_item_append_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const Elm_Gengrid_Item_Class * itc_, const void * data_, Evas_Smart_Cb func_, const void * func_data_)
{
   try
      {
         return static_cast<T*>(self->this_)->item_append(itc_, data_, func_, func_data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Widget_Item * _tmp_ret{};
         return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
::elm::widget_item elm_gengrid_item_prepend_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const Elm_Gengrid_Item_Class * itc_, const void * data_, Evas_Smart_Cb func_, const void * func_data_)
{
   try
      {
         return static_cast<T*>(self->this_)->item_prepend(itc_, data_, func_, func_data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Widget_Item * _tmp_ret{};
         return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }
}

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

template <typename T>
::elm::widget_item elm_gengrid_item_sorted_insert_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const Elm_Gengrid_Item_Class * itc_, const void * data_, Eina_Compare_Cb comp_, Evas_Smart_Cb func_, const void * func_data_)
{
   try
      {
         return static_cast<T*>(self->this_)->item_sorted_insert(itc_, data_, comp_, func_, func_data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Widget_Item * _tmp_ret{};
         return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
::elm::widget_item elm_gengrid_search_by_text_item_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Widget_Item * item_to_search_from_, const char * part_name_, const char * pattern_, Elm_Glob_Match_Flags flags_)
{
   try
      {
         return static_cast<T*>(self->this_)->search_by_text_item_get(::efl::eolian::to_cxx<::elm::widget_item>(item_to_search_from_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(part_name_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(pattern_, std::tuple<std::false_type>()), flags_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Widget_Item * _tmp_ret{};
         return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
::efl::eina::list< Elm_Gen_Item * > elm_gengrid_realized_items_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->realized_items_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_List * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Gen_Item * >>(_tmp_ret, std::tuple<std::true_type, std::false_type>());
      }
}

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

template <typename T>
::efl::eina::crange_list< ::elm::widget_item > elm_gengrid_selected_items_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->selected_items_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const Eina_List * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::crange_list< ::elm::widget_item >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }
}

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

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

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

namespace efl { namespace eo { namespace detail {

template<>
struct operations< ::elm::gengrid >
{
   template <typename T>
   struct type
         : virtual operations< ::elm::layout >::template type<T>
         , virtual operations< ::elm_interface_scrollable >::template type<T>
         , virtual operations< ::evas::clickable_interface >::template type<T>
         , virtual operations< ::elm_interface_atspi_widget_action >::template type<T>
         , virtual operations< ::elm_interface_atspi_selection >::template type<T>
   {
      virtual ::elm::widget_item item_insert_before(const Elm_Gengrid_Item_Class * itc_, const void * data_, ::elm::widget_item relative_, Evas_Smart_Cb func_, const void * func_data_)
      {
         Elm_Widget_Item * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_gengrid_item_insert_before(itc_, data_, ::efl::eolian::to_c(relative_), func_, func_data_));
            return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void realized_items_update()
      {

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

      virtual ::elm::widget_item item_insert_after(const Elm_Gengrid_Item_Class * itc_, const void * data_, ::elm::widget_item relative_, Evas_Smart_Cb func_, const void * func_data_)
      {
         Elm_Widget_Item * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_gengrid_item_insert_after(itc_, data_, ::efl::eolian::to_c(relative_), func_, func_data_));
            return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual unsigned int items_count()
      {
         unsigned int _tmp_ret = {};

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

      virtual ::elm::widget_item at_xy_item_get(Evas_Coord x_, Evas_Coord y_, int* xposret_, int* yposret_)
      {
         Elm_Widget_Item * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_gengrid_at_xy_item_get(x_, y_, xposret_, yposret_));
            return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual ::elm::widget_item item_append(const Elm_Gengrid_Item_Class * itc_, const void * data_, Evas_Smart_Cb func_, const void * func_data_)
      {
         Elm_Widget_Item * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_gengrid_item_append(itc_, data_, func_, func_data_));
            return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual ::elm::widget_item item_prepend(const Elm_Gengrid_Item_Class * itc_, const void * data_, Evas_Smart_Cb func_, const void * func_data_)
      {
         Elm_Widget_Item * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_gengrid_item_prepend(itc_, data_, func_, func_data_));
            return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void clear()
      {

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

      virtual ::elm::widget_item item_sorted_insert(const Elm_Gengrid_Item_Class * itc_, const void * data_, Eina_Compare_Cb comp_, Evas_Smart_Cb func_, const void * func_data_)
      {
         Elm_Widget_Item * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_gengrid_item_sorted_insert(itc_, data_, comp_, func_, func_data_));
            return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual ::elm::widget_item search_by_text_item_get(::elm::widget_item item_to_search_from_, ::efl::eina::string_view part_name_, ::efl::eina::string_view pattern_, Elm_Glob_Match_Flags flags_)
      {
         Elm_Widget_Item * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_gengrid_search_by_text_item_get(::efl::eolian::to_c(item_to_search_from_), ::efl::eolian::to_c(part_name_), ::efl::eolian::to_c(pattern_), flags_));
            return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void reorder_mode_start(Ecore_Pos_Map tween_mode_)
      {

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

      virtual void reorder_mode_stop()
      {

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

      virtual void align_get(double* align_x_, double* align_y_)
      {

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

      virtual void align_set(double align_x_, double align_y_)
      {

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

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

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

      virtual void filled_set(bool fill_)
      {

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

      virtual void page_relative_get(double* h_pagerel_, double* v_pagerel_)
      {

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

      virtual void page_relative_set(double h_pagerel_, double v_pagerel_)
      {

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

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

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

      virtual void multi_select_set(bool multi_)
      {

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

      virtual void group_item_size_get(Evas_Coord* w_, Evas_Coord* h_)
      {

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

      virtual void group_item_size_set(Evas_Coord w_, Evas_Coord h_)
      {

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

      virtual Elm_Object_Select_Mode select_mode_get()
      {
         Elm_Object_Select_Mode _tmp_ret = {};

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

      virtual void select_mode_set(Elm_Object_Select_Mode mode_)
      {

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

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

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

      virtual void reorder_mode_set(bool reorder_mode_)
      {

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

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

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

      virtual void highlight_mode_set(bool highlight_)
      {

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

      virtual void reorder_type_set(Elm_Gengrid_Reorder_Type type_)
      {

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

      virtual void item_size_get(Evas_Coord* w_, Evas_Coord* h_)
      {

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

      virtual void item_size_set(Evas_Coord w_, Evas_Coord h_)
      {

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

      virtual Elm_Object_Multi_Select_Mode multi_select_mode_get()
      {
         Elm_Object_Multi_Select_Mode _tmp_ret = {};

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

      virtual void multi_select_mode_set(Elm_Object_Multi_Select_Mode mode_)
      {

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

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

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

      virtual void horizontal_set(bool horizontal_)
      {

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

      virtual void page_size_set(Evas_Coord h_pagesize_, Evas_Coord v_pagesize_)
      {

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

      virtual ::elm::widget_item selected_item_get()
      {
         Elm_Widget_Item * _tmp_ret = {};

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

      virtual ::efl::eina::list< Elm_Gen_Item * > realized_items_get()
      {
         Eina_List * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_gengrid_realized_items_get());
            return ::efl::eolian::to_cxx<::efl::eina::list< Elm_Gen_Item * >>(_tmp_ret, std::tuple<std::true_type, std::false_type>());
      }

      virtual ::elm::widget_item first_item_get()
      {
         Elm_Widget_Item * _tmp_ret = {};

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

      virtual ::efl::eina::crange_list< ::elm::widget_item > selected_items_get()
      {
         const Eina_List * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_gengrid_selected_items_get());
            return ::efl::eolian::to_cxx<::efl::eina::crange_list< ::elm::widget_item >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      virtual ::elm::widget_item last_item_get()
      {
         Elm_Widget_Item * _tmp_ret = {};

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

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

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

      virtual void wheel_disabled_set(bool disabled_)
      {

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

   };
};


template<>
struct operation_description_class_size< ::elm::gengrid >
{
   static constexpr int value = 
#if defined(GENGRID_PROTECTED) && defined(GENGRID_BETA)
      43
#elif defined(GENGRID_PROTECTED)
      43
#elif defined(GENGRID_BETA)
      43
#else
      43
#endif
      + operation_description_class_size<::elm::layout >::value      + operation_description_class_size<::elm_interface_scrollable >::value      + operation_description_class_size<::evas::clickable_interface >::value      + operation_description_class_size<::elm_interface_atspi_widget_action >::value      + operation_description_class_size<::elm_interface_atspi_selection >::value;
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   initialize_operation_description<T>(::efl::eo::detail::tag<::elm::layout>(), &ops[operation_description_class_size< ::elm::gengrid >::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::elm_interface_scrollable>(), &ops[operation_description_class_size< ::elm::gengrid >::value + operation_description_class_size<::elm::layout>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::evas::clickable_interface>(), &ops[operation_description_class_size< ::elm::gengrid >::value + operation_description_class_size<::elm::layout>::value + operation_description_class_size<::elm_interface_scrollable>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::elm_interface_atspi_widget_action>(), &ops[operation_description_class_size< ::elm::gengrid >::value + operation_description_class_size<::elm::layout>::value + operation_description_class_size<::elm_interface_scrollable>::value + operation_description_class_size<::evas::clickable_interface>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::elm_interface_atspi_selection>(), &ops[operation_description_class_size< ::elm::gengrid >::value + operation_description_class_size<::elm::layout>::value + operation_description_class_size<::elm_interface_scrollable>::value + operation_description_class_size<::evas::clickable_interface>::value + operation_description_class_size<::elm_interface_atspi_widget_action>::value]);
   return 0;
}
inline Eo_Class const* get_eo_class(tag<::elm::gengrid>)
{
   return (ELM_GENGRID_CLASS);
}

} } }

/// @endcond

