/// @cond EO_CXX_EO_IMPL

inline ::evas::object elm::widget::newest_focus_order_get(unsigned int* newest_focus_order_, bool can_focus_only_) const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_newest_focus_order_get(newest_focus_order_, ::efl::eolian::to_c(can_focus_only_)));
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::scroll_hold_push() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_scroll_hold_push());
}

inline void elm::widget::cursor_add(Elm_Cursor * cur_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_cursor_add(cur_));
}

inline void elm::widget::focus_next_object_set(::evas::object next_, Elm_Focus_Direction dir_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_next_object_set(::efl::eolian::to_c(next_), dir_));
}

inline ::evas::object elm::widget::focus_next_object_get(Elm_Focus_Direction dir_) const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_next_object_get(dir_));
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::focus_next_item_set(Elm_Object_Item * next_item_, Elm_Focus_Direction dir_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_next_item_set(next_item_, dir_));
}

inline Elm_Object_Item * elm::widget::focus_next_item_get(Elm_Focus_Direction dir_) const
{
   Elm_Object_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_next_item_get(dir_));
   return _tmp_ret;
}

inline void elm::widget::focus_tree_unfocusable_handle() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_tree_unfocusable_handle());
}

inline void elm::widget::focus_custom_chain_prepend(::evas::object child_, ::evas::object relative_child_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_custom_chain_prepend(::efl::eolian::to_c(child_), ::efl::eolian::to_c(relative_child_)));
}

inline ::efl::eina::string_view elm::widget::part_text_translate(::efl::eina::string_view part_, ::efl::eina::string_view text_) const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_part_text_translate(::efl::eolian::to_c(part_), ::efl::eolian::to_c(text_)));
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::focus_highlight_geometry_get(Evas_Coord * x_, Evas_Coord * y_, Evas_Coord * w_, Evas_Coord * h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_highlight_geometry_get(x_, y_, w_, h_));
}

inline bool elm::widget::activate(Elm_Activate act_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_activate(act_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool elm::widget::sub_object_add(::evas::object sobj_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_sub_object_add(::efl::eolian::to_c(sobj_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline bool elm::widget::event(::evas::object source_, Evas_Callback_Type type_, void * event_info_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_event(::efl::eolian::to_c(source_), type_, event_info_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::event_callback_add(Elm_Event_Cb func_, const void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_event_callback_add(func_, data_));
}

inline void elm::widget::access(bool acs_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_access(::efl::eolian::to_c(acs_)));
}

inline void elm::widget::cursor_del(Elm_Cursor * cur_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_cursor_del(cur_));
}

inline void * elm::widget::event_callback_del(Elm_Event_Cb func_, const void * data_) const
{
   void * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_event_callback_del(func_, data_));
   return _tmp_ret;
}

inline bool elm::widget::on_focus(Elm_Object_Item * item_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_on_focus(item_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool elm::widget::on_focus_region(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_on_focus_region(x_, y_, w_, h_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::focus_cycle(Elm_Focus_Direction dir_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_cycle(dir_));
}

inline bool elm::widget::focus_direction(::evas::object base_, double degree_, ::evas::object* direction_, Elm_Object_Item ** direction_item_, double* weight_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_direction(::efl::eolian::to_c(base_), degree_, ::efl::eolian::to_c(direction_), direction_item_, weight_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool elm::widget::event_propagate(Evas_Callback_Type type_, void * event_info_, Evas_Event_Flags * event_flags_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_event_propagate(type_, event_info_, event_flags_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

template <typename F_func_>
inline void elm::widget::signal_callback_add(::efl::eina::string_view emission_, ::efl::eina::string_view source_, F_func_ && func_) const
{
   typedef typename std::remove_reference<F_func_>::type _no_ref_F_func_;
   _no_ref_F_func_* _tmp_func_ = new _no_ref_F_func_(std::forward< F_func_ >(func_));
   eo_do(_concrete_eo_ptr(), eo_event_callback_add(EO_BASE_EVENT_DEL, &::efl::eolian::free_callback_calback<_no_ref_F_func_>, _tmp_func_));

   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_signal_callback_add(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_), ::efl::eolian::get_callback<Edje_Signal_Cb, _no_ref_F_func_ >(), _tmp_func_));
}

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

inline ::evas::object elm::widget::name_find(::efl::eina::string_view name_, int recurse_) const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_name_find(::efl::eolian::to_c(name_), recurse_));
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool elm::widget::focus_list_direction_get(::evas::object base_, ::efl::eina::crange_list< ::eo::base > items_, list_data_get_func_type list_data_get_, double degree_, ::evas::object* direction_, Elm_Object_Item ** direction_item_, double* weight_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_list_direction_get(::efl::eolian::to_c(base_), ::efl::eolian::to_native<const Eina_List *>(items_), list_data_get_, degree_, ::efl::eolian::to_c(direction_), direction_item_, weight_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::focused_object_clear() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focused_object_clear());
}

inline bool elm::widget::focus_direction_go(double degree_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_direction_go(degree_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::show_region_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_, bool forceshow_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_show_region_set(x_, y_, w_, h_, ::efl::eolian::to_c(forceshow_)));
}

inline void elm::widget::show_region_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_show_region_get(x_, y_, w_, h_));
}

inline void elm::widget::scroll_freeze_pop() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_scroll_freeze_pop());
}

inline void elm::widget::tooltip_del(Elm_Tooltip * tt_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_tooltip_del(tt_));
}

inline bool elm::widget::focus_next_get(Elm_Focus_Direction dir_, ::evas::object* next_, Elm_Object_Item ** next_item_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_next_get(dir_, ::efl::eolian::to_c(next_), next_item_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::efl::eina::string_view elm::widget::translatable_part_text_get(::efl::eina::string_view part_) const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_translatable_part_text_get(::efl::eolian::to_c(part_)));
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::focus_restore() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_restore());
}

inline void elm::widget::scroll_hold_pop() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_scroll_hold_pop());
}

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

inline void elm::widget::scroll_freeze_push() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_scroll_freeze_push());
}

inline void elm::widget::focus_custom_chain_unset() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_custom_chain_unset());
}

inline void elm::widget::focus_steal(Elm_Object_Item * item_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_steal(item_));
}

inline void elm::widget::focus_hide_handle() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_hide_handle());
}

inline bool elm::widget::focus_next(Elm_Focus_Direction dir_, ::evas::object* next_, Elm_Object_Item ** next_item_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_next(dir_, ::efl::eolian::to_c(next_), next_item_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool elm::widget::focus_list_next_get(::efl::eina::crange_list< ::eo::base > items_, list_data_get_func_type list_data_get_, Elm_Focus_Direction dir_, ::evas::object* next_, Elm_Object_Item ** next_item_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_list_next_get(::efl::eolian::to_native<const Eina_List *>(items_), list_data_get_, dir_, ::efl::eolian::to_c(next_), next_item_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::focus_mouse_up_handle() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_mouse_up_handle());
}

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

inline bool elm::widget::focus_direction_get(::evas::object base_, double degree_, ::evas::object* direction_, Elm_Object_Item ** direction_item_, double* weight_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_direction_get(::efl::eolian::to_c(base_), degree_, ::efl::eolian::to_c(direction_), direction_item_, weight_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void * elm::widget::signal_callback_del(::efl::eina::string_view emission_, ::efl::eina::string_view source_, Edje_Signal_Cb func_) const
{
   void * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_signal_callback_del(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_), func_));
   return _tmp_ret;
}

inline void elm::widget::signal_emit(::efl::eina::string_view emission_, ::efl::eina::string_view source_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_signal_emit(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_)));
}

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

inline bool elm::widget::sub_object_del(::evas::object sobj_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_sub_object_del(::efl::eolian::to_c(sobj_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::tooltip_add(Elm_Tooltip * tt_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_tooltip_add(tt_));
}

inline void elm::widget::focus_region_show() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_region_show());
}

inline void elm::widget::focus_disabled_handle() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_disabled_handle());
}

inline void elm::widget::focus_custom_chain_append(::evas::object child_, ::evas::object relative_child_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_custom_chain_append(::efl::eolian::to_c(child_), ::efl::eolian::to_c(relative_child_)));
}

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

inline void elm::widget::focus_set(bool focus_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_set(::efl::eolian::to_c(focus_)));
}

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

inline void elm::widget::drag_lock_y_set(bool lock_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_drag_lock_y_set(::efl::eolian::to_c(lock_)));
}

inline ::efl::eina::string_view elm::widget::focus_highlight_style_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_highlight_style_get());
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool elm::widget::focus_highlight_style_set(::efl::eina::string_view style_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_highlight_style_set(::efl::eolian::to_c(style_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline void elm::widget::tree_unfocusable_set(bool tree_unfocusable_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_tree_unfocusable_set(::efl::eolian::to_c(tree_unfocusable_)));
}

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

inline void elm::widget::mirrored_set(bool mirrored_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_mirrored_set(::efl::eolian::to_c(mirrored_)));
}

inline Elm_Theme * elm::widget::theme_get() const
{
   Elm_Theme * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_theme_get());
   return _tmp_ret;
}

inline void elm::widget::theme_set(Elm_Theme * th_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_theme_set(th_));
}

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

inline void elm::widget::disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_disabled_set(::efl::eolian::to_c(disabled_)));
}

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

inline void elm::widget::highlight_ignore_set(bool ignore_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_highlight_ignore_set(::efl::eolian::to_c(ignore_)));
}

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

inline void elm::widget::mirrored_automatic_set(bool automatic_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_mirrored_automatic_set(::efl::eolian::to_c(automatic_)));
}

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

inline void elm::widget::orientation_mode_disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_orientation_mode_disabled_set(::efl::eolian::to_c(disabled_)));
}

inline ::efl::eina::string_view elm::widget::style_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_style_get());
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool elm::widget::style_set(::efl::eina::string_view style_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_style_set(::efl::eolian::to_c(style_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline double elm::widget::scale_get() const
{
   double _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_scale_get());
   return _tmp_ret;
}

inline void elm::widget::scale_set(double scale_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_scale_set(scale_));
}

inline ::efl::eina::crange_list< ::evas::object > elm::widget::focus_custom_chain_get() const
{
   const Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_custom_chain_get());
   return ::efl::eolian::to_cxx<::efl::eina::crange_list< ::evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
}

inline void elm::widget::focus_custom_chain_set(::efl::eina::range_list< ::evas::object > objs_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_custom_chain_set(::efl::eolian::to_native<Eina_List *>(objs_)));
}

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

inline void elm::widget::can_focus_set(bool can_focus_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_can_focus_set(::efl::eolian::to_c(can_focus_)));
}

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

inline void elm::widget::highlight_in_theme_set(bool highlight_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_highlight_in_theme_set(::efl::eolian::to_c(highlight_)));
}

inline ::evas::object elm::widget::parent_get() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_parent_get());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::parent_set(::evas::object parent_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_parent_set(::efl::eolian::to_c(parent_)));
}

inline ::efl::eina::optional< ::efl::eina::string_view > elm::widget::access_info_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_access_info_get());
   return ::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::access_info_set(::efl::eina::optional< ::efl::eina::string_view > txt_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_access_info_set(::efl::eolian::to_c(txt_)));
}

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

inline void elm::widget::drag_lock_x_set(bool lock_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_drag_lock_x_set(::efl::eolian::to_c(lock_)));
}

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

inline void elm::widget::access_highlight_in_theme_set(bool highlight_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_access_highlight_in_theme_set(::efl::eolian::to_c(highlight_)));
}

inline Elm_Focus_Region_Show_Mode elm::widget::focus_region_show_mode_get() const
{
   Elm_Focus_Region_Show_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_region_show_mode_get());
   return _tmp_ret;
}

inline void elm::widget::focus_region_show_mode_set(Elm_Focus_Region_Show_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_region_show_mode_set(mode_));
}

inline void elm::widget::parent_highlight_set(bool highlighted_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_parent_highlight_set(::efl::eolian::to_c(highlighted_)));
}

inline bool elm::widget::theme_object_set(::evas::object edj_, ::efl::eina::string_view wname_, ::efl::eina::string_view welement_, ::efl::eina::string_view wstyle_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_theme_object_set(::efl::eolian::to_c(edj_), ::efl::eolian::to_c(wname_), ::efl::eolian::to_c(welement_), ::efl::eolian::to_c(wstyle_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::hover_object_set(::evas::object sobj_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_hover_object_set(::efl::eolian::to_c(sobj_)));
}

inline void elm::widget::display_mode_set(Evas_Display_Mode dispmode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_display_mode_set(dispmode_));
}

inline void elm::widget::on_show_region_hook_set(region_hook_func_type func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_on_show_region_hook_set(func_, data_));
}

inline void elm::widget::domain_part_text_translatable_set(::efl::eina::string_view part_, ::efl::eina::string_view domain_, bool translatable_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_domain_part_text_translatable_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(domain_), ::efl::eolian::to_c(translatable_)));
}

inline void elm::widget::orientation_set(int rotation_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_orientation_set(rotation_));
}

inline void elm::widget::resize_object_set(::evas::object sobj_, bool sub_obj_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_resize_object_set(::efl::eolian::to_c(sobj_), ::efl::eolian::to_c(sub_obj_)));
}

inline void elm::widget::domain_translatable_part_text_set(::efl::eina::string_view part_, ::efl::eina::string_view domain_, ::efl::eina::string_view label_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_domain_translatable_part_text_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(domain_), ::efl::eolian::to_c(label_)));
}

inline ::efl::eina::list< ::evas::object > elm::widget::scrollable_children_get() const
{
   Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_scrollable_children_get());
   return ::efl::eolian::to_cxx<::efl::eina::list< ::evas::object >>(_tmp_ret, std::tuple<std::true_type, std::false_type>());
}

inline int elm::widget::scroll_hold_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_scroll_hold_get());
   return _tmp_ret;
}

inline int elm::widget::drag_child_locked_y_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_drag_child_locked_y_get());
   return _tmp_ret;
}

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

inline void elm::widget::item_loop_enabled_set(bool enable_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_item_loop_enabled_set(::efl::eolian::to_c(enable_)));
}

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

inline int elm::widget::scroll_freeze_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_scroll_freeze_get());
   return _tmp_ret;
}

inline bool elm::widget::focus_region_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_region_get(x_, y_, w_, h_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::evas::object elm::widget::top_get() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_top_get());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline unsigned int elm::widget::focus_order_get() const
{
   unsigned int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_order_get());
   return _tmp_ret;
}

inline int elm::widget::drag_child_locked_x_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_drag_child_locked_x_get());
   return _tmp_ret;
}

inline ::efl::eina::list< ::evas::object > elm::widget::can_focus_child_list_get() const
{
   Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_can_focus_child_list_get());
   return ::efl::eolian::to_cxx<::efl::eina::list< ::evas::object >>(_tmp_ret, std::tuple<std::true_type, std::false_type>());
}

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

inline void elm::widget::parents_bounce_get(Eina_Bool* horiz_, Eina_Bool* vert_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_parents_bounce_get(horiz_, vert_));
}

inline ::evas::object elm::widget::parent_widget_get() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_parent_widget_get());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline ::evas::object elm::widget::focused_object_get() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focused_object_get());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::evas::object elm::widget::parent2_get() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_parent2_get());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::parent2_set(::evas::object parent_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_parent2_set(::efl::eolian::to_c(parent_)));
}

inline ::efl::eina::string_view elm::widget::part_text_get(::efl::eina::string_view part_) const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_part_text_get(::efl::eolian::to_c(part_)));
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget::part_text_set(::efl::eina::string_view part_, ::efl::eina::string_view label_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_part_text_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(label_)));
}

inline Elm_Focus_Move_Policy elm::widget::focus_move_policy_get() const
{
   Elm_Focus_Move_Policy _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_move_policy_get());
   return _tmp_ret;
}

inline void elm::widget::focus_move_policy_set(Elm_Focus_Move_Policy policy_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_move_policy_set(policy_));
}

inline ::evas::object eo_cxx::elm::widget::newest_focus_order_get(unsigned int* newest_focus_order_, bool can_focus_only_) const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_newest_focus_order_get(newest_focus_order_, ::efl::eolian::to_c(can_focus_only_)));
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::scroll_hold_push() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_scroll_hold_push());
}

inline void eo_cxx::elm::widget::cursor_add(Elm_Cursor * cur_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_cursor_add(cur_));
}

inline void eo_cxx::elm::widget::focus_next_object_set(::evas::object next_, Elm_Focus_Direction dir_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_next_object_set(::efl::eolian::to_c(next_), dir_));
}

inline ::evas::object eo_cxx::elm::widget::focus_next_object_get(Elm_Focus_Direction dir_) const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_next_object_get(dir_));
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::focus_next_item_set(Elm_Object_Item * next_item_, Elm_Focus_Direction dir_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_next_item_set(next_item_, dir_));
}

inline Elm_Object_Item * eo_cxx::elm::widget::focus_next_item_get(Elm_Focus_Direction dir_) const
{
   Elm_Object_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_next_item_get(dir_));
   return _tmp_ret;
}

inline void eo_cxx::elm::widget::focus_tree_unfocusable_handle() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_tree_unfocusable_handle());
}

inline void eo_cxx::elm::widget::focus_custom_chain_prepend(::evas::object child_, ::evas::object relative_child_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_custom_chain_prepend(::efl::eolian::to_c(child_), ::efl::eolian::to_c(relative_child_)));
}

inline ::efl::eina::string_view eo_cxx::elm::widget::part_text_translate(::efl::eina::string_view part_, ::efl::eina::string_view text_) const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_part_text_translate(::efl::eolian::to_c(part_), ::efl::eolian::to_c(text_)));
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::focus_highlight_geometry_get(Evas_Coord * x_, Evas_Coord * y_, Evas_Coord * w_, Evas_Coord * h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_highlight_geometry_get(x_, y_, w_, h_));
}

inline bool eo_cxx::elm::widget::activate(Elm_Activate act_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_activate(act_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool eo_cxx::elm::widget::sub_object_add(::evas::object sobj_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_sub_object_add(::efl::eolian::to_c(sobj_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline bool eo_cxx::elm::widget::event(::evas::object source_, Evas_Callback_Type type_, void * event_info_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_event(::efl::eolian::to_c(source_), type_, event_info_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::event_callback_add(Elm_Event_Cb func_, const void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_event_callback_add(func_, data_));
}

inline void eo_cxx::elm::widget::access(bool acs_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_access(::efl::eolian::to_c(acs_)));
}

inline void eo_cxx::elm::widget::cursor_del(Elm_Cursor * cur_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_cursor_del(cur_));
}

inline void * eo_cxx::elm::widget::event_callback_del(Elm_Event_Cb func_, const void * data_) const
{
   void * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_event_callback_del(func_, data_));
   return _tmp_ret;
}

inline bool eo_cxx::elm::widget::on_focus(Elm_Object_Item * item_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_on_focus(item_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool eo_cxx::elm::widget::on_focus_region(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_on_focus_region(x_, y_, w_, h_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::focus_cycle(Elm_Focus_Direction dir_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_cycle(dir_));
}

inline bool eo_cxx::elm::widget::focus_direction(::evas::object base_, double degree_, ::evas::object* direction_, Elm_Object_Item ** direction_item_, double* weight_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_direction(::efl::eolian::to_c(base_), degree_, ::efl::eolian::to_c(direction_), direction_item_, weight_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool eo_cxx::elm::widget::event_propagate(Evas_Callback_Type type_, void * event_info_, Evas_Event_Flags * event_flags_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_event_propagate(type_, event_info_, event_flags_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

template <typename F_func_>
inline void eo_cxx::elm::widget::signal_callback_add(::efl::eina::string_view emission_, ::efl::eina::string_view source_, F_func_ && func_) const
{
   typedef typename std::remove_reference<F_func_>::type _no_ref_F_func_;
   _no_ref_F_func_* _tmp_func_ = new _no_ref_F_func_(std::forward< F_func_ >(func_));
   eo_do(_concrete_eo_ptr(), eo_event_callback_add(EO_BASE_EVENT_DEL, &::efl::eolian::free_callback_calback<_no_ref_F_func_>, _tmp_func_));

   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_signal_callback_add(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_), ::efl::eolian::get_callback<Edje_Signal_Cb, _no_ref_F_func_ >(), _tmp_func_));
}

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

inline ::evas::object eo_cxx::elm::widget::name_find(::efl::eina::string_view name_, int recurse_) const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_name_find(::efl::eolian::to_c(name_), recurse_));
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool eo_cxx::elm::widget::focus_list_direction_get(::evas::object base_, ::efl::eina::crange_list< ::eo::base > items_, list_data_get_func_type list_data_get_, double degree_, ::evas::object* direction_, Elm_Object_Item ** direction_item_, double* weight_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_list_direction_get(::efl::eolian::to_c(base_), ::efl::eolian::to_native<const Eina_List *>(items_), list_data_get_, degree_, ::efl::eolian::to_c(direction_), direction_item_, weight_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::focused_object_clear() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focused_object_clear());
}

inline bool eo_cxx::elm::widget::focus_direction_go(double degree_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_direction_go(degree_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::show_region_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_, bool forceshow_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_show_region_set(x_, y_, w_, h_, ::efl::eolian::to_c(forceshow_)));
}

inline void eo_cxx::elm::widget::show_region_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_show_region_get(x_, y_, w_, h_));
}

inline void eo_cxx::elm::widget::scroll_freeze_pop() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_scroll_freeze_pop());
}

inline void eo_cxx::elm::widget::tooltip_del(Elm_Tooltip * tt_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_tooltip_del(tt_));
}

inline bool eo_cxx::elm::widget::focus_next_get(Elm_Focus_Direction dir_, ::evas::object* next_, Elm_Object_Item ** next_item_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_next_get(dir_, ::efl::eolian::to_c(next_), next_item_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::efl::eina::string_view eo_cxx::elm::widget::translatable_part_text_get(::efl::eina::string_view part_) const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_translatable_part_text_get(::efl::eolian::to_c(part_)));
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::focus_restore() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_restore());
}

inline void eo_cxx::elm::widget::scroll_hold_pop() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_scroll_hold_pop());
}

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

inline void eo_cxx::elm::widget::scroll_freeze_push() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_scroll_freeze_push());
}

inline void eo_cxx::elm::widget::focus_custom_chain_unset() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_custom_chain_unset());
}

inline void eo_cxx::elm::widget::focus_steal(Elm_Object_Item * item_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_steal(item_));
}

inline void eo_cxx::elm::widget::focus_hide_handle() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_hide_handle());
}

inline bool eo_cxx::elm::widget::focus_next(Elm_Focus_Direction dir_, ::evas::object* next_, Elm_Object_Item ** next_item_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_next(dir_, ::efl::eolian::to_c(next_), next_item_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool eo_cxx::elm::widget::focus_list_next_get(::efl::eina::crange_list< ::eo::base > items_, list_data_get_func_type list_data_get_, Elm_Focus_Direction dir_, ::evas::object* next_, Elm_Object_Item ** next_item_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_list_next_get(::efl::eolian::to_native<const Eina_List *>(items_), list_data_get_, dir_, ::efl::eolian::to_c(next_), next_item_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::focus_mouse_up_handle() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_mouse_up_handle());
}

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

inline bool eo_cxx::elm::widget::focus_direction_get(::evas::object base_, double degree_, ::evas::object* direction_, Elm_Object_Item ** direction_item_, double* weight_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_direction_get(::efl::eolian::to_c(base_), degree_, ::efl::eolian::to_c(direction_), direction_item_, weight_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void * eo_cxx::elm::widget::signal_callback_del(::efl::eina::string_view emission_, ::efl::eina::string_view source_, Edje_Signal_Cb func_) const
{
   void * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_signal_callback_del(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_), func_));
   return _tmp_ret;
}

inline void eo_cxx::elm::widget::signal_emit(::efl::eina::string_view emission_, ::efl::eina::string_view source_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_signal_emit(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_)));
}

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

inline bool eo_cxx::elm::widget::sub_object_del(::evas::object sobj_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_sub_object_del(::efl::eolian::to_c(sobj_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::tooltip_add(Elm_Tooltip * tt_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_tooltip_add(tt_));
}

inline void eo_cxx::elm::widget::focus_region_show() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_region_show());
}

inline void eo_cxx::elm::widget::focus_disabled_handle() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_disabled_handle());
}

inline void eo_cxx::elm::widget::focus_custom_chain_append(::evas::object child_, ::evas::object relative_child_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_custom_chain_append(::efl::eolian::to_c(child_), ::efl::eolian::to_c(relative_child_)));
}

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

inline void eo_cxx::elm::widget::focus_set(bool focus_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_set(::efl::eolian::to_c(focus_)));
}

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

inline void eo_cxx::elm::widget::drag_lock_y_set(bool lock_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_drag_lock_y_set(::efl::eolian::to_c(lock_)));
}

inline ::efl::eina::string_view eo_cxx::elm::widget::focus_highlight_style_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_highlight_style_get());
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool eo_cxx::elm::widget::focus_highlight_style_set(::efl::eina::string_view style_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_highlight_style_set(::efl::eolian::to_c(style_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline void eo_cxx::elm::widget::tree_unfocusable_set(bool tree_unfocusable_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_tree_unfocusable_set(::efl::eolian::to_c(tree_unfocusable_)));
}

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

inline void eo_cxx::elm::widget::mirrored_set(bool mirrored_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_mirrored_set(::efl::eolian::to_c(mirrored_)));
}

inline Elm_Theme * eo_cxx::elm::widget::theme_get() const
{
   Elm_Theme * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_theme_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::widget::theme_set(Elm_Theme * th_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_theme_set(th_));
}

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

inline void eo_cxx::elm::widget::disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_disabled_set(::efl::eolian::to_c(disabled_)));
}

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

inline void eo_cxx::elm::widget::highlight_ignore_set(bool ignore_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_highlight_ignore_set(::efl::eolian::to_c(ignore_)));
}

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

inline void eo_cxx::elm::widget::mirrored_automatic_set(bool automatic_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_mirrored_automatic_set(::efl::eolian::to_c(automatic_)));
}

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

inline void eo_cxx::elm::widget::orientation_mode_disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_orientation_mode_disabled_set(::efl::eolian::to_c(disabled_)));
}

inline ::efl::eina::string_view eo_cxx::elm::widget::style_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_style_get());
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool eo_cxx::elm::widget::style_set(::efl::eina::string_view style_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_style_set(::efl::eolian::to_c(style_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline double eo_cxx::elm::widget::scale_get() const
{
   double _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_scale_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::widget::scale_set(double scale_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_scale_set(scale_));
}

inline ::efl::eina::crange_list< ::evas::object > eo_cxx::elm::widget::focus_custom_chain_get() const
{
   const Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_custom_chain_get());
   return ::efl::eolian::to_cxx<::efl::eina::crange_list< ::evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
}

inline void eo_cxx::elm::widget::focus_custom_chain_set(::efl::eina::range_list< ::evas::object > objs_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_custom_chain_set(::efl::eolian::to_native<Eina_List *>(objs_)));
}

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

inline void eo_cxx::elm::widget::can_focus_set(bool can_focus_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_can_focus_set(::efl::eolian::to_c(can_focus_)));
}

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

inline void eo_cxx::elm::widget::highlight_in_theme_set(bool highlight_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_highlight_in_theme_set(::efl::eolian::to_c(highlight_)));
}

inline ::evas::object eo_cxx::elm::widget::parent_get() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_parent_get());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::parent_set(::evas::object parent_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_parent_set(::efl::eolian::to_c(parent_)));
}

inline ::efl::eina::optional< ::efl::eina::string_view > eo_cxx::elm::widget::access_info_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_access_info_get());
   return ::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::access_info_set(::efl::eina::optional< ::efl::eina::string_view > txt_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_access_info_set(::efl::eolian::to_c(txt_)));
}

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

inline void eo_cxx::elm::widget::drag_lock_x_set(bool lock_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_drag_lock_x_set(::efl::eolian::to_c(lock_)));
}

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

inline void eo_cxx::elm::widget::access_highlight_in_theme_set(bool highlight_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_access_highlight_in_theme_set(::efl::eolian::to_c(highlight_)));
}

inline Elm_Focus_Region_Show_Mode eo_cxx::elm::widget::focus_region_show_mode_get() const
{
   Elm_Focus_Region_Show_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_region_show_mode_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::widget::focus_region_show_mode_set(Elm_Focus_Region_Show_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_region_show_mode_set(mode_));
}

inline void eo_cxx::elm::widget::parent_highlight_set(bool highlighted_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_parent_highlight_set(::efl::eolian::to_c(highlighted_)));
}

inline bool eo_cxx::elm::widget::theme_object_set(::evas::object edj_, ::efl::eina::string_view wname_, ::efl::eina::string_view welement_, ::efl::eina::string_view wstyle_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_theme_object_set(::efl::eolian::to_c(edj_), ::efl::eolian::to_c(wname_), ::efl::eolian::to_c(welement_), ::efl::eolian::to_c(wstyle_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::hover_object_set(::evas::object sobj_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_hover_object_set(::efl::eolian::to_c(sobj_)));
}

inline void eo_cxx::elm::widget::display_mode_set(Evas_Display_Mode dispmode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_display_mode_set(dispmode_));
}

inline void eo_cxx::elm::widget::on_show_region_hook_set(region_hook_func_type func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_on_show_region_hook_set(func_, data_));
}

inline void eo_cxx::elm::widget::domain_part_text_translatable_set(::efl::eina::string_view part_, ::efl::eina::string_view domain_, bool translatable_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_domain_part_text_translatable_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(domain_), ::efl::eolian::to_c(translatable_)));
}

inline void eo_cxx::elm::widget::orientation_set(int rotation_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_orientation_set(rotation_));
}

inline void eo_cxx::elm::widget::resize_object_set(::evas::object sobj_, bool sub_obj_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_resize_object_set(::efl::eolian::to_c(sobj_), ::efl::eolian::to_c(sub_obj_)));
}

inline void eo_cxx::elm::widget::domain_translatable_part_text_set(::efl::eina::string_view part_, ::efl::eina::string_view domain_, ::efl::eina::string_view label_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_domain_translatable_part_text_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(domain_), ::efl::eolian::to_c(label_)));
}

inline ::efl::eina::list< ::evas::object > eo_cxx::elm::widget::scrollable_children_get() const
{
   Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_scrollable_children_get());
   return ::efl::eolian::to_cxx<::efl::eina::list< ::evas::object >>(_tmp_ret, std::tuple<std::true_type, std::false_type>());
}

inline int eo_cxx::elm::widget::scroll_hold_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_scroll_hold_get());
   return _tmp_ret;
}

inline int eo_cxx::elm::widget::drag_child_locked_y_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_drag_child_locked_y_get());
   return _tmp_ret;
}

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

inline void eo_cxx::elm::widget::item_loop_enabled_set(bool enable_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_item_loop_enabled_set(::efl::eolian::to_c(enable_)));
}

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

inline int eo_cxx::elm::widget::scroll_freeze_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_scroll_freeze_get());
   return _tmp_ret;
}

inline bool eo_cxx::elm::widget::focus_region_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_region_get(x_, y_, w_, h_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::evas::object eo_cxx::elm::widget::top_get() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_top_get());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline unsigned int eo_cxx::elm::widget::focus_order_get() const
{
   unsigned int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_order_get());
   return _tmp_ret;
}

inline int eo_cxx::elm::widget::drag_child_locked_x_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_drag_child_locked_x_get());
   return _tmp_ret;
}

inline ::efl::eina::list< ::evas::object > eo_cxx::elm::widget::can_focus_child_list_get() const
{
   Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_can_focus_child_list_get());
   return ::efl::eolian::to_cxx<::efl::eina::list< ::evas::object >>(_tmp_ret, std::tuple<std::true_type, std::false_type>());
}

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

inline void eo_cxx::elm::widget::parents_bounce_get(Eina_Bool* horiz_, Eina_Bool* vert_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_parents_bounce_get(horiz_, vert_));
}

inline ::evas::object eo_cxx::elm::widget::parent_widget_get() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_parent_widget_get());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline ::evas::object eo_cxx::elm::widget::focused_object_get() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focused_object_get());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::evas::object eo_cxx::elm::widget::parent2_get() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_parent2_get());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::parent2_set(::evas::object parent_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_parent2_set(::efl::eolian::to_c(parent_)));
}

inline ::efl::eina::string_view eo_cxx::elm::widget::part_text_get(::efl::eina::string_view part_) const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_part_text_get(::efl::eolian::to_c(part_)));
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget::part_text_set(::efl::eina::string_view part_, ::efl::eina::string_view label_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_part_text_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(label_)));
}

inline Elm_Focus_Move_Policy eo_cxx::elm::widget::focus_move_policy_get() const
{
   Elm_Focus_Move_Policy _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_widget_focus_move_policy_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::widget::focus_move_policy_set(Elm_Focus_Move_Policy policy_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_widget_focus_move_policy_set(policy_));
}

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

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

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

template <typename T>
::evas::object elm_widget_newest_focus_order_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, unsigned int* newest_focus_order_, Eina_Bool can_focus_only_)
{
   try
      {
         return static_cast<T*>(self->this_)->newest_focus_order_get(newest_focus_order_, ::efl::eolian::to_cxx<bool>(can_focus_only_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Evas_Object * _tmp_ret{};
         return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }
}

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

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

template <typename T>
void elm_widget_focus_next_object_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Object * next_, Elm_Focus_Direction dir_)
{
   try
      {
         static_cast<T*>(self->this_)->focus_next_object_set(::efl::eolian::to_cxx<::evas::object>(next_, std::tuple<std::false_type>()), dir_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::evas::object elm_widget_focus_next_object_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Focus_Direction dir_)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_next_object_get(dir_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Evas_Object * _tmp_ret{};
         return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_focus_next_item_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Object_Item * next_item_, Elm_Focus_Direction dir_)
{
   try
      {
         static_cast<T*>(self->this_)->focus_next_item_set(next_item_, dir_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

template <typename T>
void elm_widget_focus_custom_chain_prepend_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_, Evas_Object * relative_child_)
{
   try
      {
         static_cast<T*>(self->this_)->focus_custom_chain_prepend(::efl::eolian::to_cxx<::evas::object>(child_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::evas::object>(relative_child_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::efl::eina::string_view elm_widget_part_text_translate_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_, const char * text_)
{
   try
      {
         return static_cast<T*>(self->this_)->part_text_translate(::efl::eolian::to_cxx<::efl::eina::string_view>(part_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(text_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const char * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }
}

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

template <typename T>
bool elm_widget_activate_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Activate act_)
{
   try
      {
         return static_cast<T*>(self->this_)->activate(act_);
      }
   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>
bool elm_widget_sub_object_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Object * sobj_)
{
   try
      {
         return static_cast<T*>(self->this_)->sub_object_add(::efl::eolian::to_cxx<::evas::object>(sobj_, std::tuple<std::false_type>()));
      }
   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>
bool elm_widget_focus_direction_manager_is_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_direction_manager_is();
      }
   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>
bool elm_widget_event_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Object * source_, Evas_Callback_Type type_, void * event_info_)
{
   try
      {
         return static_cast<T*>(self->this_)->event(::efl::eolian::to_cxx<::evas::object>(source_, std::tuple<std::false_type>()), type_, event_info_);
      }
   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_widget_event_callback_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Event_Cb func_, const void * data_)
{
   try
      {
         static_cast<T*>(self->this_)->event_callback_add(func_, data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

template <typename T>
void * elm_widget_event_callback_del_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Event_Cb func_, const void * data_)
{
   try
      {
         return static_cast<T*>(self->this_)->event_callback_del(func_, data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         void * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
bool elm_widget_on_focus_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Object_Item * item_)
{
   try
      {
         return static_cast<T*>(self->this_)->on_focus(item_);
      }
   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>
bool elm_widget_on_focus_region_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
{
   try
      {
         return static_cast<T*>(self->this_)->on_focus_region(x_, y_, w_, h_);
      }
   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_widget_focus_cycle_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Focus_Direction dir_)
{
   try
      {
         static_cast<T*>(self->this_)->focus_cycle(dir_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_focus_direction_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const Evas_Object * base_, double degree_, Evas_Object ** direction_, Elm_Object_Item ** direction_item_, double* weight_)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_direction(::efl::eolian::to_cxx<::evas::object>(base_, std::tuple<std::false_type>()), degree_, ::efl::eolian::to_cxx<::evas::object*>(direction_, std::tuple<std::false_type>()), direction_item_, weight_);
      }
   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>
bool elm_widget_event_propagate_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Callback_Type type_, void * event_info_, Evas_Event_Flags * event_flags_)
{
   try
      {
         return static_cast<T*>(self->this_)->event_propagate(type_, event_info_, event_flags_);
      }
   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_widget_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_)
{
   try
      {
         static_cast<T*>(self->this_)->signal_callback_add(::efl::eolian::to_cxx<::efl::eina::string_view>(emission_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(source_, std::tuple<std::false_type>()), func_, data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_focus_next_manager_is_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_next_manager_is();
      }
   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>
::evas::object elm_widget_name_find_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * name_, int recurse_)
{
   try
      {
         return static_cast<T*>(self->this_)->name_find(::efl::eolian::to_cxx<::efl::eina::string_view>(name_, std::tuple<std::false_type>()), recurse_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Evas_Object * _tmp_ret{};
         return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
bool elm_widget_focus_list_direction_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const Evas_Object * base_, const Eina_List * items_, list_data_get_func_type list_data_get_, double degree_, Evas_Object ** direction_, Elm_Object_Item ** direction_item_, double* weight_)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_list_direction_get(::efl::eolian::to_cxx<::evas::object>(base_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::crange_list< ::eo::base >>(items_, std::tuple<std::false_type, std::false_type>()), list_data_get_, degree_, ::efl::eolian::to_cxx<::evas::object*>(direction_, std::tuple<std::false_type>()), direction_item_, weight_);
      }
   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_widget_focused_object_clear_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->focused_object_clear();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_focus_direction_go_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, double degree_)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_direction_go(degree_);
      }
   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_widget_show_region_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_, Eina_Bool forceshow_)
{
   try
      {
         static_cast<T*>(self->this_)->show_region_set(x_, y_, w_, h_, ::efl::eolian::to_cxx<bool>(forceshow_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

template <typename T>
bool elm_widget_focus_next_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Focus_Direction dir_, Evas_Object ** next_, Elm_Object_Item ** next_item_)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_next_get(dir_, ::efl::eolian::to_cxx<::evas::object*>(next_, std::tuple<std::false_type>()), next_item_);
      }
   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>
::efl::eina::string_view elm_widget_translatable_part_text_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_)
{
   try
      {
         return static_cast<T*>(self->this_)->translatable_part_text_get(::efl::eolian::to_cxx<::efl::eina::string_view>(part_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const char * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }
}

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

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

template <typename T>
bool elm_widget_translate_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->translate();
      }
   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_widget_scroll_freeze_push_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->scroll_freeze_push();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

template <typename T>
bool elm_widget_focus_next_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Focus_Direction dir_, Evas_Object ** next_, Elm_Object_Item ** next_item_)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_next(dir_, ::efl::eolian::to_cxx<::evas::object*>(next_, std::tuple<std::false_type>()), next_item_);
      }
   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>
bool elm_widget_focus_list_next_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const Eina_List * items_, list_data_get_func_type list_data_get_, Elm_Focus_Direction dir_, Evas_Object ** next_, Elm_Object_Item ** next_item_)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_list_next_get(::efl::eolian::to_cxx<::efl::eina::crange_list< ::eo::base >>(items_, std::tuple<std::false_type, std::false_type>()), list_data_get_, dir_, ::efl::eolian::to_cxx<::evas::object*>(next_, std::tuple<std::false_type>()), next_item_);
      }
   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_widget_focus_mouse_up_handle_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->focus_mouse_up_handle();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_theme_apply_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->theme_apply();
      }
   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>
bool elm_widget_focus_direction_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const Evas_Object * base_, double degree_, Evas_Object ** direction_, Elm_Object_Item ** direction_item_, double* weight_)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_direction_get(::efl::eolian::to_cxx<::evas::object>(base_, std::tuple<std::false_type>()), degree_, ::efl::eolian::to_cxx<::evas::object*>(direction_, std::tuple<std::false_type>()), direction_item_, weight_);
      }
   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_widget_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_)
{
   try
      {
         return static_cast<T*>(self->this_)->signal_callback_del(::efl::eolian::to_cxx<::efl::eina::string_view>(emission_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(source_, std::tuple<std::false_type>()), func_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         void * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_widget_signal_emit_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * emission_, const char * source_)
{
   try
      {
         static_cast<T*>(self->this_)->signal_emit(::efl::eolian::to_cxx<::efl::eina::string_view>(emission_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(source_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_disable_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->disable();
      }
   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>
bool elm_widget_sub_object_del_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Object * sobj_)
{
   try
      {
         return static_cast<T*>(self->this_)->sub_object_del(::efl::eolian::to_cxx<::evas::object>(sobj_, std::tuple<std::false_type>()));
      }
   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_widget_tooltip_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Tooltip * tt_)
{
   try
      {
         static_cast<T*>(self->this_)->tooltip_add(tt_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

template <typename T>
void elm_widget_focus_custom_chain_append_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Object * child_, Evas_Object * relative_child_)
{
   try
      {
         static_cast<T*>(self->this_)->focus_custom_chain_append(::efl::eolian::to_cxx<::evas::object>(child_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::evas::object>(relative_child_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_focus_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_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_widget_focus_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool focus_)
{
   try
      {
         static_cast<T*>(self->this_)->focus_set(::efl::eolian::to_cxx<bool>(focus_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_drag_lock_y_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->drag_lock_y_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_widget_drag_lock_y_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool lock_)
{
   try
      {
         static_cast<T*>(self->this_)->drag_lock_y_set(::efl::eolian::to_cxx<bool>(lock_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

template <typename T>
bool elm_widget_focus_highlight_style_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * style_)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_highlight_style_set(::efl::eolian::to_cxx<::efl::eina::string_view>(style_, std::tuple<std::false_type>()));
      }
   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>
bool elm_widget_tree_unfocusable_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->tree_unfocusable_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_widget_tree_unfocusable_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool tree_unfocusable_)
{
   try
      {
         static_cast<T*>(self->this_)->tree_unfocusable_set(::efl::eolian::to_cxx<bool>(tree_unfocusable_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_mirrored_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->mirrored_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_widget_mirrored_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool mirrored_)
{
   try
      {
         static_cast<T*>(self->this_)->mirrored_set(::efl::eolian::to_cxx<bool>(mirrored_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

template <typename T>
bool elm_widget_disabled_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->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_widget_disabled_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool disabled_)
{
   try
      {
         static_cast<T*>(self->this_)->disabled_set(::efl::eolian::to_cxx<bool>(disabled_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_highlight_ignore_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->highlight_ignore_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_widget_highlight_ignore_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool ignore_)
{
   try
      {
         static_cast<T*>(self->this_)->highlight_ignore_set(::efl::eolian::to_cxx<bool>(ignore_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_mirrored_automatic_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->mirrored_automatic_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_widget_mirrored_automatic_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool automatic_)
{
   try
      {
         static_cast<T*>(self->this_)->mirrored_automatic_set(::efl::eolian::to_cxx<bool>(automatic_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_orientation_mode_disabled_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->orientation_mode_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_widget_orientation_mode_disabled_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool disabled_)
{
   try
      {
         static_cast<T*>(self->this_)->orientation_mode_disabled_set(::efl::eolian::to_cxx<bool>(disabled_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

template <typename T>
bool elm_widget_style_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * style_)
{
   try
      {
         return static_cast<T*>(self->this_)->style_set(::efl::eolian::to_cxx<::efl::eina::string_view>(style_, std::tuple<std::false_type>()));
      }
   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>
double elm_widget_scale_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->scale_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         double _tmp_ret{};
         return _tmp_ret;
      }
}

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

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

template <typename T>
void elm_widget_focus_custom_chain_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_List * objs_)
{
   try
      {
         static_cast<T*>(self->this_)->focus_custom_chain_set(::efl::eolian::to_cxx<::efl::eina::range_list< ::evas::object >>(objs_, std::tuple<std::false_type, std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_can_focus_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->can_focus_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_widget_can_focus_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool can_focus_)
{
   try
      {
         static_cast<T*>(self->this_)->can_focus_set(::efl::eolian::to_cxx<bool>(can_focus_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_highlight_in_theme_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->highlight_in_theme_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_widget_highlight_in_theme_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool highlight_)
{
   try
      {
         static_cast<T*>(self->this_)->highlight_in_theme_set(::efl::eolian::to_cxx<bool>(highlight_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

template <typename T>
void elm_widget_parent_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Object * parent_)
{
   try
      {
         static_cast<T*>(self->this_)->parent_set(::efl::eolian::to_cxx<::evas::object>(parent_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::efl::eina::optional< ::efl::eina::string_view > elm_widget_access_info_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->access_info_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const char * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_access_info_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * txt_)
{
   try
      {
         static_cast<T*>(self->this_)->access_info_set(::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(txt_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_drag_lock_x_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->drag_lock_x_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_widget_drag_lock_x_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool lock_)
{
   try
      {
         static_cast<T*>(self->this_)->drag_lock_x_set(::efl::eolian::to_cxx<bool>(lock_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_access_highlight_in_theme_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->access_highlight_in_theme_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_widget_access_highlight_in_theme_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool highlight_)
{
   try
      {
         static_cast<T*>(self->this_)->access_highlight_in_theme_set(::efl::eolian::to_cxx<bool>(highlight_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

template <typename T>
bool elm_widget_theme_object_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Object * edj_, const char * wname_, const char * welement_, const char * wstyle_)
{
   try
      {
         return static_cast<T*>(self->this_)->theme_object_set(::efl::eolian::to_cxx<::evas::object>(edj_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(wname_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(welement_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(wstyle_, std::tuple<std::false_type>()));
      }
   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_widget_hover_object_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Object * sobj_)
{
   try
      {
         static_cast<T*>(self->this_)->hover_object_set(::efl::eolian::to_cxx<::evas::object>(sobj_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

template <typename T>
void elm_widget_domain_part_text_translatable_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_, const char * domain_, Eina_Bool translatable_)
{
   try
      {
         static_cast<T*>(self->this_)->domain_part_text_translatable_set(::efl::eolian::to_cxx<::efl::eina::string_view>(part_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(domain_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<bool>(translatable_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

template <typename T>
void elm_widget_resize_object_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Object * sobj_, Eina_Bool sub_obj_)
{
   try
      {
         static_cast<T*>(self->this_)->resize_object_set(::efl::eolian::to_cxx<::evas::object>(sobj_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<bool>(sub_obj_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
void elm_widget_domain_translatable_part_text_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_, const char * domain_, const char * label_)
{
   try
      {
         static_cast<T*>(self->this_)->domain_translatable_part_text_set(::efl::eolian::to_cxx<::efl::eina::string_view>(part_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(domain_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(label_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

template <typename T>
bool elm_widget_item_loop_enabled_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->item_loop_enabled_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_widget_item_loop_enabled_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool enable_)
{
   try
      {
         static_cast<T*>(self->this_)->item_loop_enabled_set(::efl::eolian::to_cxx<bool>(enable_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_child_can_focus_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->child_can_focus_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>
int elm_widget_scroll_freeze_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->scroll_freeze_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         int _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
bool elm_widget_focus_region_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_region_get(x_, y_, w_, h_);
      }
   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>
::evas::object elm_widget_top_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->top_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Evas_Object * _tmp_ret{};
         return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }
}

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

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

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

template <typename T>
::elm::widget_item elm_widget_focused_item_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->focused_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>
void elm_widget_parents_bounce_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool* horiz_, Eina_Bool* vert_)
{
   try
      {
         static_cast<T*>(self->this_)->parents_bounce_get(horiz_, vert_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

template <typename T>
bool elm_widget_highlight_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->highlight_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>
::evas::object elm_widget_focused_object_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->focused_object_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Evas_Object * _tmp_ret{};
         return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }
}

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

template <typename T>
void elm_widget_parent2_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Object * parent_)
{
   try
      {
         static_cast<T*>(self->this_)->parent2_set(::efl::eolian::to_cxx<::evas::object>(parent_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::efl::eina::string_view elm_widget_part_text_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_)
{
   try
      {
         return static_cast<T*>(self->this_)->part_text_get(::efl::eolian::to_cxx<::efl::eina::string_view>(part_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const char * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_part_text_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_, const char * label_)
{
   try
      {
         static_cast<T*>(self->this_)->part_text_set(::efl::eolian::to_cxx<::efl::eina::string_view>(part_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(label_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

namespace efl { namespace eo { namespace detail {

template<>
struct operations< ::elm::widget >
{
   template <typename T>
   struct type
         : virtual operations< ::evas::object_smart >::template type<T>
         , virtual operations< ::elm_interface_atspi_accessible >::template type<T>
         , virtual operations< ::elm_interface_atspi_component >::template type<T>
   {
      virtual ::evas::object newest_focus_order_get(unsigned int* newest_focus_order_, bool can_focus_only_)
      {
         Evas_Object * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_widget_newest_focus_order_get(newest_focus_order_, ::efl::eolian::to_c(can_focus_only_)));
            return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void scroll_hold_push()
      {

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

      virtual void cursor_add(Elm_Cursor * cur_)
      {

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

      virtual void focus_next_object_set(::evas::object next_, Elm_Focus_Direction dir_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_widget_focus_next_object_set(::efl::eolian::to_c(next_), dir_));
      }

      virtual ::evas::object focus_next_object_get(Elm_Focus_Direction dir_)
      {
         Evas_Object * _tmp_ret = {};

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

      virtual void focus_next_item_set(Elm_Object_Item * next_item_, Elm_Focus_Direction dir_)
      {

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

      virtual Elm_Object_Item * focus_next_item_get(Elm_Focus_Direction dir_)
      {
         Elm_Object_Item * _tmp_ret = {};

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

      virtual void focus_tree_unfocusable_handle()
      {

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

      virtual void focus_custom_chain_prepend(::evas::object child_, ::evas::object relative_child_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_widget_focus_custom_chain_prepend(::efl::eolian::to_c(child_), ::efl::eolian::to_c(relative_child_)));
      }

      virtual ::efl::eina::string_view part_text_translate(::efl::eina::string_view part_, ::efl::eina::string_view text_)
      {
         const char * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_widget_part_text_translate(::efl::eolian::to_c(part_), ::efl::eolian::to_c(text_)));
            return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void focus_highlight_geometry_get(Evas_Coord * x_, Evas_Coord * y_, Evas_Coord * w_, Evas_Coord * h_)
      {

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

      virtual bool activate(Elm_Activate act_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual bool sub_object_add(::evas::object sobj_)
      {
         Eina_Bool _tmp_ret = {};

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

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

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

      virtual bool event(::evas::object source_, Evas_Callback_Type type_, void * event_info_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual void event_callback_add(Elm_Event_Cb func_, const void * data_)
      {

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

      virtual void access(bool acs_)
      {

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

      virtual void cursor_del(Elm_Cursor * cur_)
      {

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

      virtual void * event_callback_del(Elm_Event_Cb func_, const void * data_)
      {
         void * _tmp_ret = {};

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

      virtual bool on_focus(Elm_Object_Item * item_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual bool on_focus_region(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual void focus_cycle(Elm_Focus_Direction dir_)
      {

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

      virtual bool focus_direction(::evas::object base_, double degree_, ::evas::object* direction_, Elm_Object_Item ** direction_item_, double* weight_)
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_widget_focus_direction(::efl::eolian::to_c(base_), degree_, ::efl::eolian::to_c(direction_), direction_item_, weight_));
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool event_propagate(Evas_Callback_Type type_, void * event_info_, Evas_Event_Flags * event_flags_)
      {
         Eina_Bool _tmp_ret = {};

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

      template <typename F_func_>
      void signal_callback_add(::efl::eina::string_view emission_, ::efl::eina::string_view source_, F_func_ && func_)
      {
         typedef typename std::remove_reference<F_func_>::type _no_ref_F_func_;
         _no_ref_F_func_* _tmp_func_ = new _no_ref_F_func_(std::forward< F_func_ >(func_));
         eo_do(dynamic_cast<T*>(this)->_eo_ptr(), eo_event_callback_add(EO_BASE_EVENT_DEL, &::efl::eolian::free_callback_calback<_no_ref_F_func_>, _tmp_func_));


         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_widget_signal_callback_add(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_), ::efl::eolian::get_callback<Edje_Signal_Cb, _no_ref_F_func_ >(), _tmp_func_));
      }

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

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

      virtual ::evas::object name_find(::efl::eina::string_view name_, int recurse_)
      {
         Evas_Object * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_widget_name_find(::efl::eolian::to_c(name_), recurse_));
            return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool focus_list_direction_get(::evas::object base_, ::efl::eina::crange_list< ::eo::base > items_, list_data_get_func_type list_data_get_, double degree_, ::evas::object* direction_, Elm_Object_Item ** direction_item_, double* weight_)
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_widget_focus_list_direction_get(::efl::eolian::to_c(base_), ::efl::eolian::to_native<const Eina_List *>(items_), list_data_get_, degree_, ::efl::eolian::to_c(direction_), direction_item_, weight_));
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void focused_object_clear()
      {

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

      virtual bool focus_direction_go(double degree_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual void show_region_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_, bool forceshow_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_widget_show_region_set(x_, y_, w_, h_, ::efl::eolian::to_c(forceshow_)));
      }

      virtual void show_region_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {

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

      virtual void scroll_freeze_pop()
      {

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

      virtual void tooltip_del(Elm_Tooltip * tt_)
      {

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

      virtual bool focus_next_get(Elm_Focus_Direction dir_, ::evas::object* next_, Elm_Object_Item ** next_item_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual ::efl::eina::string_view translatable_part_text_get(::efl::eina::string_view part_)
      {
         const char * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_widget_translatable_part_text_get(::efl::eolian::to_c(part_)));
            return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void focus_restore()
      {

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

      virtual void scroll_hold_pop()
      {

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

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

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

      virtual void scroll_freeze_push()
      {

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

      virtual void focus_custom_chain_unset()
      {

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

      virtual void focus_steal(Elm_Object_Item * item_)
      {

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

      virtual void focus_hide_handle()
      {

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

      virtual bool focus_next(Elm_Focus_Direction dir_, ::evas::object* next_, Elm_Object_Item ** next_item_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual bool focus_list_next_get(::efl::eina::crange_list< ::eo::base > items_, list_data_get_func_type list_data_get_, Elm_Focus_Direction dir_, ::evas::object* next_, Elm_Object_Item ** next_item_)
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_widget_focus_list_next_get(::efl::eolian::to_native<const Eina_List *>(items_), list_data_get_, dir_, ::efl::eolian::to_c(next_), next_item_));
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void focus_mouse_up_handle()
      {

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

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

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

      virtual bool focus_direction_get(::evas::object base_, double degree_, ::evas::object* direction_, Elm_Object_Item ** direction_item_, double* weight_)
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_widget_focus_direction_get(::efl::eolian::to_c(base_), degree_, ::efl::eolian::to_c(direction_), direction_item_, weight_));
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void * signal_callback_del(::efl::eina::string_view emission_, ::efl::eina::string_view source_, Edje_Signal_Cb func_)
      {
         void * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_widget_signal_callback_del(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_), func_));
            return _tmp_ret;
      }

      virtual void signal_emit(::efl::eina::string_view emission_, ::efl::eina::string_view source_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_widget_signal_emit(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_)));
      }

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

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

      virtual bool sub_object_del(::evas::object sobj_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual void tooltip_add(Elm_Tooltip * tt_)
      {

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

      virtual void focus_region_show()
      {

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

      virtual void focus_disabled_handle()
      {

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

      virtual void focus_custom_chain_append(::evas::object child_, ::evas::object relative_child_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_widget_focus_custom_chain_append(::efl::eolian::to_c(child_), ::efl::eolian::to_c(relative_child_)));
      }

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

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

      virtual void focus_set(bool focus_)
      {

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

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

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

      virtual void drag_lock_y_set(bool lock_)
      {

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

      virtual ::efl::eina::string_view focus_highlight_style_get()
      {
         const char * _tmp_ret = {};

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

      virtual bool focus_highlight_style_set(::efl::eina::string_view style_)
      {
         Eina_Bool _tmp_ret = {};

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

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

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

      virtual void tree_unfocusable_set(bool tree_unfocusable_)
      {

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

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

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

      virtual void mirrored_set(bool mirrored_)
      {

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

      virtual Elm_Theme * theme_get()
      {
         Elm_Theme * _tmp_ret = {};

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

      virtual void theme_set(Elm_Theme * th_)
      {

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

      virtual bool 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_widget_disabled_get());
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void disabled_set(bool disabled_)
      {

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

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

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

      virtual void highlight_ignore_set(bool ignore_)
      {

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

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

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

      virtual void mirrored_automatic_set(bool automatic_)
      {

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

      virtual bool orientation_mode_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_widget_orientation_mode_disabled_get());
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void orientation_mode_disabled_set(bool disabled_)
      {

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

      virtual ::efl::eina::string_view style_get()
      {
         const char * _tmp_ret = {};

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

      virtual bool style_set(::efl::eina::string_view style_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual double scale_get()
      {
         double _tmp_ret = {};

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

      virtual void scale_set(double scale_)
      {

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

      virtual ::efl::eina::crange_list< ::evas::object > focus_custom_chain_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_widget_focus_custom_chain_get());
            return ::efl::eolian::to_cxx<::efl::eina::crange_list< ::evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      virtual void focus_custom_chain_set(::efl::eina::range_list< ::evas::object > objs_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_widget_focus_custom_chain_set(::efl::eolian::to_native<Eina_List *>(objs_)));
      }

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

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

      virtual void can_focus_set(bool can_focus_)
      {

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

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

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

      virtual void highlight_in_theme_set(bool highlight_)
      {

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

      virtual ::evas::object parent_get()
      {
         Evas_Object * _tmp_ret = {};

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

      virtual void parent_set(::evas::object parent_)
      {

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

      virtual ::efl::eina::optional< ::efl::eina::string_view > access_info_get()
      {
         const char * _tmp_ret = {};

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

      virtual void access_info_set(::efl::eina::optional< ::efl::eina::string_view > txt_)
      {

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

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

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

      virtual void drag_lock_x_set(bool lock_)
      {

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

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

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

      virtual void access_highlight_in_theme_set(bool highlight_)
      {

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

      virtual Elm_Focus_Region_Show_Mode focus_region_show_mode_get()
      {
         Elm_Focus_Region_Show_Mode _tmp_ret = {};

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

      virtual void focus_region_show_mode_set(Elm_Focus_Region_Show_Mode mode_)
      {

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

      virtual void parent_highlight_set(bool highlighted_)
      {

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

      virtual bool theme_object_set(::evas::object edj_, ::efl::eina::string_view wname_, ::efl::eina::string_view welement_, ::efl::eina::string_view wstyle_)
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_widget_theme_object_set(::efl::eolian::to_c(edj_), ::efl::eolian::to_c(wname_), ::efl::eolian::to_c(welement_), ::efl::eolian::to_c(wstyle_)));
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void hover_object_set(::evas::object sobj_)
      {

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

      virtual void display_mode_set(Evas_Display_Mode dispmode_)
      {

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

      virtual void on_show_region_hook_set(region_hook_func_type func_, void * data_)
      {

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

      virtual void domain_part_text_translatable_set(::efl::eina::string_view part_, ::efl::eina::string_view domain_, bool translatable_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_widget_domain_part_text_translatable_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(domain_), ::efl::eolian::to_c(translatable_)));
      }

      virtual void orientation_set(int rotation_)
      {

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

      virtual void resize_object_set(::evas::object sobj_, bool sub_obj_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_widget_resize_object_set(::efl::eolian::to_c(sobj_), ::efl::eolian::to_c(sub_obj_)));
      }

      virtual void domain_translatable_part_text_set(::efl::eina::string_view part_, ::efl::eina::string_view domain_, ::efl::eina::string_view label_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_widget_domain_translatable_part_text_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(domain_), ::efl::eolian::to_c(label_)));
      }

      virtual ::efl::eina::list< ::evas::object > scrollable_children_get()
      {
         Eina_List * _tmp_ret = {};

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

      virtual int scroll_hold_get()
      {
         int _tmp_ret = {};

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

      virtual int drag_child_locked_y_get()
      {
         int _tmp_ret = {};

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

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

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

      virtual void item_loop_enabled_set(bool enable_)
      {

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

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

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

      virtual int scroll_freeze_get()
      {
         int _tmp_ret = {};

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

      virtual bool focus_region_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual ::evas::object top_get()
      {
         Evas_Object * _tmp_ret = {};

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

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

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

      virtual int drag_child_locked_x_get()
      {
         int _tmp_ret = {};

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

      virtual ::efl::eina::list< ::evas::object > can_focus_child_list_get()
      {
         Eina_List * _tmp_ret = {};

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

      virtual ::elm::widget_item focused_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_widget_focused_item_get());
            return ::efl::eolian::to_cxx<::elm::widget_item>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void parents_bounce_get(Eina_Bool* horiz_, Eina_Bool* vert_)
      {

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

      virtual ::evas::object parent_widget_get()
      {
         Evas_Object * _tmp_ret = {};

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

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

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

      virtual ::evas::object focused_object_get()
      {
         Evas_Object * _tmp_ret = {};

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

      virtual ::evas::object parent2_get()
      {
         Evas_Object * _tmp_ret = {};

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

      virtual void parent2_set(::evas::object parent_)
      {

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

      virtual ::efl::eina::string_view part_text_get(::efl::eina::string_view part_)
      {
         const char * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_widget_part_text_get(::efl::eolian::to_c(part_)));
            return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void part_text_set(::efl::eina::string_view part_, ::efl::eina::string_view label_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_widget_part_text_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(label_)));
      }

      virtual Elm_Focus_Move_Policy focus_move_policy_get()
      {
         Elm_Focus_Move_Policy _tmp_ret = {};

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

      virtual void focus_move_policy_set(Elm_Focus_Move_Policy policy_)
      {

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

   };
};


template<>
struct operation_description_class_size< ::elm::widget >
{
   static constexpr int value = 
#if defined(WIDGET_PROTECTED) && defined(WIDGET_BETA)
      128
#elif defined(WIDGET_PROTECTED)
      128
#elif defined(WIDGET_BETA)
      128
#else
      128
#endif
      + operation_description_class_size<::evas::object_smart >::value      + operation_description_class_size<::elm_interface_atspi_accessible >::value      + operation_description_class_size<::elm_interface_atspi_component >::value;
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   initialize_operation_description<T>(::efl::eo::detail::tag<::evas::object_smart>(), &ops[operation_description_class_size< ::elm::widget >::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::elm_interface_atspi_accessible>(), &ops[operation_description_class_size< ::elm::widget >::value + operation_description_class_size<::evas::object_smart>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::elm_interface_atspi_component>(), &ops[operation_description_class_size< ::elm::widget >::value + operation_description_class_size<::evas::object_smart>::value + operation_description_class_size<::elm_interface_atspi_accessible>::value]);
   return 0;
}
inline Eo_Class const* get_eo_class(tag<::elm::widget>)
{
   return (ELM_WIDGET_CLASS);
}

} } }

/// @endcond

