/// @cond EO_CXX_EO_IMPL

inline bool elm::web::navigate(int steps_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_navigate(steps_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline bool elm::web::html_string_load(::efl::eina::string_view html_, ::efl::eina::optional< ::efl::eina::string_view > base_url_, ::efl::eina::optional< ::efl::eina::string_view > unreachable_url_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_html_string_load(::efl::eolian::to_c(html_), ::efl::eolian::to_c(base_url_), ::efl::eolian::to_c(unreachable_url_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool elm::web::text_search(::efl::eina::string_view string_, bool case_sensitive_, bool forward_, bool wrap_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_text_search(::efl::eolian::to_c(string_), ::efl::eolian::to_c(case_sensitive_), ::efl::eolian::to_c(forward_), ::efl::eolian::to_c(wrap_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline void elm::web::region_show(int x_, int y_, int w_, int h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_region_show(x_, y_, w_, h_));
}

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

inline unsigned int elm::web::text_matches_mark(::efl::eina::string_view string_, bool case_sensitive_, bool highlight_, unsigned int limit_) const
{
   unsigned int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_text_matches_mark(::efl::eolian::to_c(string_), ::efl::eolian::to_c(case_sensitive_), ::efl::eolian::to_c(highlight_), limit_));
   return _tmp_ret;
}

inline void elm::web::region_bring_in(int x_, int y_, int w_, int h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_region_bring_in(x_, y_, w_, h_));
}

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

inline bool elm::web::navigate_possible_get(int steps_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_navigate_possible_get(steps_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

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

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

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

inline bool elm::web::text_matches_highlight_set(bool highlight_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_text_matches_highlight_set(::efl::eolian::to_c(highlight_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline void elm::web::useragent_set(::efl::eina::string_view user_agent_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_useragent_set(::efl::eolian::to_c(user_agent_)));
}

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

inline bool elm::web::url_set(::efl::eina::string_view url_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_url_set(::efl::eolian::to_c(url_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::web::bg_color_get(int* r_, int* g_, int* b_, int* a_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_bg_color_get(r_, g_, b_, a_));
}

inline void elm::web::bg_color_set(int r_, int g_, int b_, int a_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_bg_color_set(r_, g_, b_, a_));
}

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

inline void elm::web::inwin_mode_set(bool value_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_inwin_mode_set(::efl::eolian::to_c(value_)));
}

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

inline void elm::web::tab_propagate_set(bool propagate_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_tab_propagate_set(::efl::eolian::to_c(propagate_)));
}

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

inline void elm::web::history_enabled_set(bool enable_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_history_enabled_set(::efl::eolian::to_c(enable_)));
}

inline Elm_Web_Zoom_Mode elm::web::zoom_mode_get() const
{
   Elm_Web_Zoom_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_zoom_mode_get());
   return _tmp_ret;
}

inline void elm::web::zoom_mode_set(Elm_Web_Zoom_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_zoom_mode_set(mode_));
}

inline double elm::web::zoom_get() const
{
   double _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_zoom_get());
   return _tmp_ret;
}

inline void elm::web::zoom_set(double zoom_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_zoom_set(zoom_));
}

inline void elm::web::console_message_hook_set(Elm_Web_Console_Message func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_console_message_hook_set(func_, data_));
}

inline void elm::web::window_create_hook_set(Elm_Web_Window_Open func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_window_create_hook_set(func_, data_));
}

inline void elm::web::dialog_file_selector_hook_set(Elm_Web_Dialog_File_Selector func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_dialog_file_selector_hook_set(func_, data_));
}

inline void elm::web::dialog_confirm_hook_set(Elm_Web_Dialog_Confirm func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_dialog_confirm_hook_set(func_, data_));
}

inline void elm::web::popup_selected_set(int idx_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_popup_selected_set(idx_));
}

inline void elm::web::dialog_prompt_hook_set(Elm_Web_Dialog_Prompt func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_dialog_prompt_hook_set(func_, data_));
}

inline void elm::web::dialog_alert_hook_set(Elm_Web_Dialog_Alert func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_dialog_alert_hook_set(func_, data_));
}

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

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

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

inline double elm::web::load_progress_get() const
{
   double _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_load_progress_get());
   return _tmp_ret;
}

inline const char * elm::web::selection_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_selection_get());
   return _tmp_ret;
}

inline const char * elm::web::title_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_title_get());
   return _tmp_ret;
}

inline bool eo_cxx::elm::web::navigate(int steps_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_navigate(steps_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline bool eo_cxx::elm::web::html_string_load(::efl::eina::string_view html_, ::efl::eina::optional< ::efl::eina::string_view > base_url_, ::efl::eina::optional< ::efl::eina::string_view > unreachable_url_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_html_string_load(::efl::eolian::to_c(html_), ::efl::eolian::to_c(base_url_), ::efl::eolian::to_c(unreachable_url_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool eo_cxx::elm::web::text_search(::efl::eina::string_view string_, bool case_sensitive_, bool forward_, bool wrap_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_text_search(::efl::eolian::to_c(string_), ::efl::eolian::to_c(case_sensitive_), ::efl::eolian::to_c(forward_), ::efl::eolian::to_c(wrap_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline void eo_cxx::elm::web::region_show(int x_, int y_, int w_, int h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_region_show(x_, y_, w_, h_));
}

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

inline unsigned int eo_cxx::elm::web::text_matches_mark(::efl::eina::string_view string_, bool case_sensitive_, bool highlight_, unsigned int limit_) const
{
   unsigned int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_text_matches_mark(::efl::eolian::to_c(string_), ::efl::eolian::to_c(case_sensitive_), ::efl::eolian::to_c(highlight_), limit_));
   return _tmp_ret;
}

inline void eo_cxx::elm::web::region_bring_in(int x_, int y_, int w_, int h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_region_bring_in(x_, y_, w_, h_));
}

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

inline bool eo_cxx::elm::web::navigate_possible_get(int steps_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_navigate_possible_get(steps_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

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

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

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

inline bool eo_cxx::elm::web::text_matches_highlight_set(bool highlight_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_text_matches_highlight_set(::efl::eolian::to_c(highlight_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline void eo_cxx::elm::web::useragent_set(::efl::eina::string_view user_agent_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_useragent_set(::efl::eolian::to_c(user_agent_)));
}

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

inline bool eo_cxx::elm::web::url_set(::efl::eina::string_view url_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_url_set(::efl::eolian::to_c(url_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::web::bg_color_get(int* r_, int* g_, int* b_, int* a_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_bg_color_get(r_, g_, b_, a_));
}

inline void eo_cxx::elm::web::bg_color_set(int r_, int g_, int b_, int a_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_bg_color_set(r_, g_, b_, a_));
}

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

inline void eo_cxx::elm::web::inwin_mode_set(bool value_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_inwin_mode_set(::efl::eolian::to_c(value_)));
}

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

inline void eo_cxx::elm::web::tab_propagate_set(bool propagate_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_tab_propagate_set(::efl::eolian::to_c(propagate_)));
}

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

inline void eo_cxx::elm::web::history_enabled_set(bool enable_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_history_enabled_set(::efl::eolian::to_c(enable_)));
}

inline Elm_Web_Zoom_Mode eo_cxx::elm::web::zoom_mode_get() const
{
   Elm_Web_Zoom_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_zoom_mode_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::web::zoom_mode_set(Elm_Web_Zoom_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_zoom_mode_set(mode_));
}

inline double eo_cxx::elm::web::zoom_get() const
{
   double _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_zoom_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::web::zoom_set(double zoom_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_zoom_set(zoom_));
}

inline void eo_cxx::elm::web::console_message_hook_set(Elm_Web_Console_Message func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_console_message_hook_set(func_, data_));
}

inline void eo_cxx::elm::web::window_create_hook_set(Elm_Web_Window_Open func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_window_create_hook_set(func_, data_));
}

inline void eo_cxx::elm::web::dialog_file_selector_hook_set(Elm_Web_Dialog_File_Selector func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_dialog_file_selector_hook_set(func_, data_));
}

inline void eo_cxx::elm::web::dialog_confirm_hook_set(Elm_Web_Dialog_Confirm func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_dialog_confirm_hook_set(func_, data_));
}

inline void eo_cxx::elm::web::popup_selected_set(int idx_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_popup_selected_set(idx_));
}

inline void eo_cxx::elm::web::dialog_prompt_hook_set(Elm_Web_Dialog_Prompt func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_dialog_prompt_hook_set(func_, data_));
}

inline void eo_cxx::elm::web::dialog_alert_hook_set(Elm_Web_Dialog_Alert func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_web_dialog_alert_hook_set(func_, data_));
}

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

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

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

inline double eo_cxx::elm::web::load_progress_get() const
{
   double _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_load_progress_get());
   return _tmp_ret;
}

inline const char * eo_cxx::elm::web::selection_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_selection_get());
   return _tmp_ret;
}

inline const char * eo_cxx::elm::web::title_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_web_title_get());
   return _tmp_ret;
}

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

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

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

template <typename T>
bool elm_web_navigate_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int steps_)
{
   try
      {
         return static_cast<T*>(self->this_)->navigate(steps_);
      }
   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_web_back_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->back();
      }
   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_web_html_string_load_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * html_, const char * base_url_, const char * unreachable_url_)
{
   try
      {
         return static_cast<T*>(self->this_)->html_string_load(::efl::eolian::to_cxx<::efl::eina::string_view>(html_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(base_url_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(unreachable_url_, 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_web_text_search_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * string_, Eina_Bool case_sensitive_, Eina_Bool forward_, Eina_Bool wrap_)
{
   try
      {
         return static_cast<T*>(self->this_)->text_search(::efl::eolian::to_cxx<::efl::eina::string_view>(string_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<bool>(case_sensitive_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<bool>(forward_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<bool>(wrap_, 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_web_popup_destroy_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->popup_destroy();
      }
   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_web_region_show_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int x_, int y_, int w_, int h_)
{
   try
      {
         static_cast<T*>(self->this_)->region_show(x_, y_, w_, h_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_web_forward_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->forward();
      }
   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>
unsigned int elm_web_text_matches_mark_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * string_, Eina_Bool case_sensitive_, Eina_Bool highlight_, unsigned int limit_)
{
   try
      {
         return static_cast<T*>(self->this_)->text_matches_mark(::efl::eolian::to_cxx<::efl::eina::string_view>(string_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<bool>(case_sensitive_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<bool>(highlight_, std::tuple<std::false_type>()), limit_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         unsigned int _tmp_ret{};
         return _tmp_ret;
      }
}

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

template <typename T>
bool elm_web_stop_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->stop();
      }
   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_web_navigate_possible_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int steps_)
{
   try
      {
         return static_cast<T*>(self->this_)->navigate_possible_get(steps_);
      }
   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_web_reload_full_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->reload_full();
      }
   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_web_text_matches_unmark_all_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->text_matches_unmark_all();
      }
   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_web_reload_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->reload();
      }
   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_web_text_matches_highlight_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->text_matches_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>
bool elm_web_text_matches_highlight_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool highlight_)
{
   try
      {
         return static_cast<T*>(self->this_)->text_matches_highlight_set(::efl::eolian::to_cxx<bool>(highlight_, 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>
::efl::eina::string_view elm_web_useragent_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->useragent_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>
void elm_web_useragent_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * user_agent_)
{
   try
      {
         static_cast<T*>(self->this_)->useragent_set(::efl::eolian::to_cxx<::efl::eina::string_view>(user_agent_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::efl::eina::string_view elm_web_url_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->url_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_web_url_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * url_)
{
   try
      {
         return static_cast<T*>(self->this_)->url_set(::efl::eolian::to_cxx<::efl::eina::string_view>(url_, 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_web_bg_color_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int* r_, int* g_, int* b_, int* a_)
{
   try
      {
         static_cast<T*>(self->this_)->bg_color_get(r_, g_, b_, a_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
void elm_web_bg_color_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int r_, int g_, int b_, int a_)
{
   try
      {
         static_cast<T*>(self->this_)->bg_color_set(r_, g_, b_, a_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
bool elm_web_forward_possible_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->forward_possible_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_web_webkit_view_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->webkit_view_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_web_back_possible_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->back_possible_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>
double elm_web_load_progress_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->load_progress_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         double _tmp_ret{};
         return _tmp_ret;
      }
}

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

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

namespace efl { namespace eo { namespace detail {

template<>
struct operations< ::elm::web >
{
   template <typename T>
   struct type
         : virtual operations< ::elm::widget >::template type<T>
   {
      virtual bool navigate(int steps_)
      {
         Eina_Bool _tmp_ret = {};

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

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

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

      virtual bool html_string_load(::efl::eina::string_view html_, ::efl::eina::optional< ::efl::eina::string_view > base_url_, ::efl::eina::optional< ::efl::eina::string_view > unreachable_url_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual bool text_search(::efl::eina::string_view string_, bool case_sensitive_, bool forward_, bool wrap_)
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_web_text_search(::efl::eolian::to_c(string_), ::efl::eolian::to_c(case_sensitive_), ::efl::eolian::to_c(forward_), ::efl::eolian::to_c(wrap_)));
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

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

      virtual void region_show(int x_, int y_, int w_, int h_)
      {

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

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

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

      virtual unsigned int text_matches_mark(::efl::eina::string_view string_, bool case_sensitive_, bool highlight_, unsigned int limit_)
      {
         unsigned int _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_web_text_matches_mark(::efl::eolian::to_c(string_), ::efl::eolian::to_c(case_sensitive_), ::efl::eolian::to_c(highlight_), limit_));
            return _tmp_ret;
      }

      virtual void region_bring_in(int x_, int y_, int w_, int h_)
      {

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

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

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

      virtual bool navigate_possible_get(int steps_)
      {
         Eina_Bool _tmp_ret = {};

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

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

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

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

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

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

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

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

      virtual bool text_matches_highlight_set(bool highlight_)
      {
         Eina_Bool _tmp_ret = {};

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

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

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

      virtual void useragent_set(::efl::eina::string_view user_agent_)
      {

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

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

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

      virtual bool url_set(::efl::eina::string_view url_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual void bg_color_get(int* r_, int* g_, int* b_, int* a_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_web_bg_color_get(r_, g_, b_, a_));
      }

      virtual void bg_color_set(int r_, int g_, int b_, int a_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_web_bg_color_set(r_, g_, b_, a_));
      }

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

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

      virtual void inwin_mode_set(bool value_)
      {

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

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

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

      virtual void tab_propagate_set(bool propagate_)
      {

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

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

      virtual void history_enabled_set(bool enable_)
      {

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

      virtual Elm_Web_Zoom_Mode zoom_mode_get()
      {
         Elm_Web_Zoom_Mode _tmp_ret = {};

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

      virtual void zoom_mode_set(Elm_Web_Zoom_Mode mode_)
      {

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

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

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

      virtual void zoom_set(double zoom_)
      {

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

      virtual void console_message_hook_set(Elm_Web_Console_Message func_, void * data_)
      {

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

      virtual void window_create_hook_set(Elm_Web_Window_Open func_, void * data_)
      {

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

      virtual void dialog_file_selector_hook_set(Elm_Web_Dialog_File_Selector func_, void * data_)
      {

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

      virtual void dialog_confirm_hook_set(Elm_Web_Dialog_Confirm func_, void * data_)
      {

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

      virtual void popup_selected_set(int idx_)
      {

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

      virtual void dialog_prompt_hook_set(Elm_Web_Dialog_Prompt func_, void * data_)
      {

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

      virtual void dialog_alert_hook_set(Elm_Web_Dialog_Alert func_, void * data_)
      {

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

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

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

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

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

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

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

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

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

      virtual const char * selection_get()
      {
         const char * _tmp_ret = {};

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

      virtual const char * title_get()
      {
         const char * _tmp_ret = {};

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

   };
};


template<>
struct operation_description_class_size< ::elm::web >
{
   static constexpr int value = 
#if defined(WEB_PROTECTED) && defined(WEB_BETA)
      45
#elif defined(WEB_PROTECTED)
      45
#elif defined(WEB_BETA)
      45
#else
      45
#endif
      + operation_description_class_size<::elm::widget >::value;
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   initialize_operation_description<T>(::efl::eo::detail::tag<::elm::widget>(), &ops[operation_description_class_size< ::elm::web >::value]);
   return 0;
}
inline Eo_Class const* get_eo_class(tag<::elm::web>)
{
   return (ELM_WEB_CLASS);
}

} } }

/// @endcond

