/// @cond EO_CXX_EO_IMPL

inline ::elm::win::_c_name elm::win::name(::efl::eina::optional< ::efl::eina::string_view > name_)
{
   return _c_name(name_);
}

inline ::elm::win::_c_type elm::win::type(Elm_Win_Type type_)
{
   return _c_type(type_);
}

inline void elm::win::wm_manual_rotation_done_manual() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_wm_manual_rotation_done_manual());
}

inline bool elm::win::socket_listen(::efl::eina::string_view svcname_, int svcnum_, bool svcsys_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_socket_listen(::efl::eolian::to_c(svcname_), svcnum_, ::efl::eolian::to_c(svcsys_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::win::illume_command_send(Elm_Illume_Command command_, void * params_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_illume_command_send(command_, params_));
}

inline void elm::win::activate() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_activate());
}

inline void elm::win::resize_object_add(::evas::object subobj_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_resize_object_add(::efl::eolian::to_c(subobj_)));
}

inline void elm::win::raise() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_raise());
}

inline void elm::win::lower() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_lower());
}

inline void elm::win::resize_object_del(::evas::object subobj_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_resize_object_del(::efl::eolian::to_c(subobj_)));
}

inline void elm::win::center(bool h_, bool v_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_center(::efl::eolian::to_c(h_), ::efl::eolian::to_c(v_)));
}

inline bool elm::win::keygrab_set(::efl::eina::string_view key_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_, int proirity_, Elm_Win_Keygrab_Mode grab_mode_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_keygrab_set(::efl::eolian::to_c(key_), modifiers_, not_modifiers_, proirity_, grab_mode_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool elm::win::keygrab_unset(::efl::eina::string_view key_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_keygrab_unset(::efl::eolian::to_c(key_), modifiers_, not_modifiers_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline void elm::win::keyboard_win_set(bool is_keyboard_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_keyboard_win_set(::efl::eolian::to_c(is_keyboard_)));
}

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

inline void elm::win::autodel_set(bool autodel_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_autodel_set(::efl::eolian::to_c(autodel_)));
}

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

inline void elm::win::autohide_set(bool autohide_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_autohide_set(::efl::eolian::to_c(autohide_)));
}

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

inline void elm::win::override_set(bool override_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_override_set(::efl::eolian::to_c(override_)));
}

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

inline void elm::win::iconified_set(bool iconified_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_iconified_set(::efl::eolian::to_c(iconified_)));
}

inline bool elm::win::wm_available_rotations_get(int ** rotations_, unsigned int* count_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_wm_available_rotations_get(rotations_, count_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::win::wm_available_rotations_set(const int * rotations_, unsigned int count_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_wm_available_rotations_set(rotations_, count_));
}

inline int elm::win::quickpanel_zone_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_quickpanel_zone_get());
   return _tmp_ret;
}

inline void elm::win::quickpanel_zone_set(int zone_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_quickpanel_zone_set(zone_));
}

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

inline void elm::win::maximized_set(bool maximized_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_maximized_set(::efl::eolian::to_c(maximized_)));
}

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

inline void elm::win::modal_set(bool modal_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_modal_set(::efl::eolian::to_c(modal_)));
}

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

inline void elm::win::icon_name_set(::efl::eina::string_view icon_name_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_icon_name_set(::efl::eolian::to_c(icon_name_)));
}

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

inline void elm::win::withdrawn_set(bool withdrawn_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_withdrawn_set(::efl::eolian::to_c(withdrawn_)));
}

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

inline void elm::win::role_set(::efl::eina::string_view role_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_role_set(::efl::eolian::to_c(role_)));
}

inline void elm::win::size_step_get(int* w_, int* h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_size_step_get(w_, h_));
}

inline void elm::win::size_step_set(int w_, int h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_size_step_set(w_, h_));
}

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

inline void elm::win::focus_highlight_style_set(::efl::eina::optional< ::efl::eina::string_view > style_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_focus_highlight_style_set(::efl::eolian::to_c(style_)));
}

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

inline void elm::win::borderless_set(bool borderless_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_borderless_set(::efl::eolian::to_c(borderless_)));
}

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

inline void elm::win::screen_constrain_set(bool constrain_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_screen_constrain_set(::efl::eolian::to_c(constrain_)));
}

inline bool elm::win::available_profiles_get(char *** profiles_, unsigned int* count_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_available_profiles_get(profiles_, count_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::win::available_profiles_set(const char ** profiles_, unsigned int count_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_available_profiles_set(profiles_, count_));
}

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

inline void elm::win::focus_highlight_enabled_set(bool enabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_focus_highlight_enabled_set(::efl::eolian::to_c(enabled_)));
}

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

inline void elm::win::title_set(::efl::eina::string_view title_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_title_set(::efl::eolian::to_c(title_)));
}

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

inline void elm::win::alpha_set(bool alpha_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_alpha_set(::efl::eolian::to_c(alpha_)));
}

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

inline void elm::win::urgent_set(bool urgent_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_urgent_set(::efl::eolian::to_c(urgent_)));
}

inline int elm::win::rotation_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_rotation_get());
   return _tmp_ret;
}

inline void elm::win::rotation_set(int rotation_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_rotation_set(rotation_));
}

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

inline void elm::win::icon_object_set(::evas::object icon_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_icon_object_set(::efl::eolian::to_c(icon_)));
}

inline int elm::win::quickpanel_priority_minor_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_quickpanel_priority_minor_get());
   return _tmp_ret;
}

inline void elm::win::quickpanel_priority_minor_set(int priority_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_quickpanel_priority_minor_set(priority_));
}

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

inline void elm::win::sticky_set(bool sticky_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_sticky_set(::efl::eolian::to_c(sticky_)));
}

inline Elm_Win_Keyboard_Mode elm::win::keyboard_mode_get() const
{
   Elm_Win_Keyboard_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_keyboard_mode_get());
   return _tmp_ret;
}

inline void elm::win::keyboard_mode_set(Elm_Win_Keyboard_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_keyboard_mode_set(mode_));
}

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

inline void elm::win::focus_highlight_animate_set(bool animate_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_focus_highlight_animate_set(::efl::eolian::to_c(animate_)));
}

inline double elm::win::aspect_get() const
{
   double _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_aspect_get());
   return _tmp_ret;
}

inline void elm::win::aspect_set(double aspect_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_aspect_set(aspect_));
}

inline int elm::win::quickpanel_priority_major_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_quickpanel_priority_major_get());
   return _tmp_ret;
}

inline void elm::win::quickpanel_priority_major_set(int priority_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_quickpanel_priority_major_set(priority_));
}

inline Elm_Win_Indicator_Opacity_Mode elm::win::indicator_opacity_get() const
{
   Elm_Win_Indicator_Opacity_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_indicator_opacity_get());
   return _tmp_ret;
}

inline void elm::win::indicator_opacity_set(Elm_Win_Indicator_Opacity_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_indicator_opacity_set(mode_));
}

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

inline void elm::win::demand_attention_set(bool demand_attention_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_demand_attention_set(::efl::eolian::to_c(demand_attention_)));
}

inline int elm::win::wm_preferred_rotation_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_wm_preferred_rotation_get());
   return _tmp_ret;
}

inline void elm::win::wm_preferred_rotation_set(int rotation_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_wm_preferred_rotation_set(rotation_));
}

inline int elm::win::layer_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_layer_get());
   return _tmp_ret;
}

inline void elm::win::layer_set(int layer_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_layer_set(layer_));
}

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

inline void elm::win::profile_set(::efl::eina::string_view profile_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_profile_set(::efl::eolian::to_c(profile_)));
}

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

inline void elm::win::shaped_set(bool shaped_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_shaped_set(::efl::eolian::to_c(shaped_)));
}

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

inline void elm::win::fullscreen_set(bool fullscreen_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_fullscreen_set(::efl::eolian::to_c(fullscreen_)));
}

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

inline void elm::win::wm_manual_rotation_done_set(bool set_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_wm_manual_rotation_done_set(::efl::eolian::to_c(set_)));
}

inline Elm_Win_Indicator_Mode elm::win::indicator_mode_get() const
{
   Elm_Win_Indicator_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_indicator_mode_get());
   return _tmp_ret;
}

inline void elm::win::indicator_mode_set(Elm_Win_Indicator_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_indicator_mode_set(mode_));
}

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

inline void elm::win::conformant_set(bool conformant_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_conformant_set(::efl::eolian::to_c(conformant_)));
}

inline void elm::win::size_base_get(int* w_, int* h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_size_base_get(w_, h_));
}

inline void elm::win::size_base_set(int w_, int h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_size_base_set(w_, h_));
}

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

inline void elm::win::quickpanel_set(bool quickpanel_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_quickpanel_set(::efl::eolian::to_c(quickpanel_)));
}

inline void elm::win::rotation_with_resize_set(int rotation_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_rotation_with_resize_set(rotation_));
}

inline void elm::win::prop_focus_skip_set(bool skip_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_prop_focus_skip_set(::efl::eolian::to_c(skip_)));
}

inline void elm::win::screen_position_get(int* x_, int* y_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_screen_position_get(x_, y_));
}

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

inline Ecore_X_Window elm::win::xwindow_get() const
{
   Ecore_X_Window _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_xwindow_get());
   return _tmp_ret;
}

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

inline void elm::win::screen_size_get(int* x_, int* y_, int* w_, int* h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_screen_size_get(x_, y_, w_, h_));
}

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

inline Ecore_Wl2_Window * elm::win::wl_window_get() const
{
   Ecore_Wl2_Window * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_wl_window_get());
   return _tmp_ret;
}

inline Ecore_Cocoa_Window * elm::win::cocoa_window_get() const
{
   Ecore_Cocoa_Window * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_cocoa_window_get());
   return _tmp_ret;
}

inline Ecore_Win32_Window * elm::win::win32_window_get() const
{
   Ecore_Win32_Window * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_win32_window_get());
   return _tmp_ret;
}

inline Ecore_Window elm::win::window_id_get() const
{
   Ecore_Window _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_window_id_get());
   return _tmp_ret;
}

inline void elm::win::screen_dpi_get(int* xdpi_, int* ydpi_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_screen_dpi_get(xdpi_, ydpi_));
}

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

inline void elm::win::name_set(::efl::eina::optional< ::efl::eina::string_view > name_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_name_set(::efl::eolian::to_c(name_)));
}

inline Elm_Win_Type elm::win::type_get() const
{
   Elm_Win_Type _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_type_get());
   return _tmp_ret;
}

inline void elm::win::type_set(Elm_Win_Type type_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_type_set(type_));
}

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

inline void elm::win::noblank_set(bool noblank_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_noblank_set(::efl::eolian::to_c(noblank_)));
}

inline void * elm::win::trap_data_get() const
{
   void * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_trap_data_get());
   return _tmp_ret;
}

#ifdef WIN_PROTECTED
inline void elm::win::fake_canvas_set(Ecore_Evas * oee_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_fake_canvas_set(oee_));
}
#endif

inline void eo_cxx::elm::win::wm_manual_rotation_done_manual() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_wm_manual_rotation_done_manual());
}

inline bool eo_cxx::elm::win::socket_listen(::efl::eina::string_view svcname_, int svcnum_, bool svcsys_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_socket_listen(::efl::eolian::to_c(svcname_), svcnum_, ::efl::eolian::to_c(svcsys_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::win::illume_command_send(Elm_Illume_Command command_, void * params_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_illume_command_send(command_, params_));
}

inline void eo_cxx::elm::win::activate() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_activate());
}

inline void eo_cxx::elm::win::resize_object_add(::evas::object subobj_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_resize_object_add(::efl::eolian::to_c(subobj_)));
}

inline void eo_cxx::elm::win::raise() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_raise());
}

inline void eo_cxx::elm::win::lower() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_lower());
}

inline void eo_cxx::elm::win::resize_object_del(::evas::object subobj_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_resize_object_del(::efl::eolian::to_c(subobj_)));
}

inline void eo_cxx::elm::win::center(bool h_, bool v_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_center(::efl::eolian::to_c(h_), ::efl::eolian::to_c(v_)));
}

inline bool eo_cxx::elm::win::keygrab_set(::efl::eina::string_view key_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_, int proirity_, Elm_Win_Keygrab_Mode grab_mode_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_keygrab_set(::efl::eolian::to_c(key_), modifiers_, not_modifiers_, proirity_, grab_mode_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool eo_cxx::elm::win::keygrab_unset(::efl::eina::string_view key_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_keygrab_unset(::efl::eolian::to_c(key_), modifiers_, not_modifiers_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline void eo_cxx::elm::win::keyboard_win_set(bool is_keyboard_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_keyboard_win_set(::efl::eolian::to_c(is_keyboard_)));
}

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

inline void eo_cxx::elm::win::autodel_set(bool autodel_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_autodel_set(::efl::eolian::to_c(autodel_)));
}

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

inline void eo_cxx::elm::win::autohide_set(bool autohide_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_autohide_set(::efl::eolian::to_c(autohide_)));
}

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

inline void eo_cxx::elm::win::override_set(bool override_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_override_set(::efl::eolian::to_c(override_)));
}

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

inline void eo_cxx::elm::win::iconified_set(bool iconified_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_iconified_set(::efl::eolian::to_c(iconified_)));
}

inline bool eo_cxx::elm::win::wm_available_rotations_get(int ** rotations_, unsigned int* count_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_wm_available_rotations_get(rotations_, count_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::win::wm_available_rotations_set(const int * rotations_, unsigned int count_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_wm_available_rotations_set(rotations_, count_));
}

inline int eo_cxx::elm::win::quickpanel_zone_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_quickpanel_zone_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::win::quickpanel_zone_set(int zone_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_quickpanel_zone_set(zone_));
}

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

inline void eo_cxx::elm::win::maximized_set(bool maximized_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_maximized_set(::efl::eolian::to_c(maximized_)));
}

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

inline void eo_cxx::elm::win::modal_set(bool modal_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_modal_set(::efl::eolian::to_c(modal_)));
}

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

inline void eo_cxx::elm::win::icon_name_set(::efl::eina::string_view icon_name_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_icon_name_set(::efl::eolian::to_c(icon_name_)));
}

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

inline void eo_cxx::elm::win::withdrawn_set(bool withdrawn_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_withdrawn_set(::efl::eolian::to_c(withdrawn_)));
}

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

inline void eo_cxx::elm::win::role_set(::efl::eina::string_view role_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_role_set(::efl::eolian::to_c(role_)));
}

inline void eo_cxx::elm::win::size_step_get(int* w_, int* h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_size_step_get(w_, h_));
}

inline void eo_cxx::elm::win::size_step_set(int w_, int h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_size_step_set(w_, h_));
}

inline ::efl::eina::optional< ::efl::eina::string_view > eo_cxx::elm::win::focus_highlight_style_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_focus_highlight_style_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::win::focus_highlight_style_set(::efl::eina::optional< ::efl::eina::string_view > style_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_focus_highlight_style_set(::efl::eolian::to_c(style_)));
}

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

inline void eo_cxx::elm::win::borderless_set(bool borderless_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_borderless_set(::efl::eolian::to_c(borderless_)));
}

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

inline void eo_cxx::elm::win::screen_constrain_set(bool constrain_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_screen_constrain_set(::efl::eolian::to_c(constrain_)));
}

inline bool eo_cxx::elm::win::available_profiles_get(char *** profiles_, unsigned int* count_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_available_profiles_get(profiles_, count_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::win::available_profiles_set(const char ** profiles_, unsigned int count_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_available_profiles_set(profiles_, count_));
}

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

inline void eo_cxx::elm::win::focus_highlight_enabled_set(bool enabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_focus_highlight_enabled_set(::efl::eolian::to_c(enabled_)));
}

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

inline void eo_cxx::elm::win::title_set(::efl::eina::string_view title_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_title_set(::efl::eolian::to_c(title_)));
}

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

inline void eo_cxx::elm::win::alpha_set(bool alpha_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_alpha_set(::efl::eolian::to_c(alpha_)));
}

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

inline void eo_cxx::elm::win::urgent_set(bool urgent_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_urgent_set(::efl::eolian::to_c(urgent_)));
}

inline int eo_cxx::elm::win::rotation_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_rotation_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::win::rotation_set(int rotation_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_rotation_set(rotation_));
}

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

inline void eo_cxx::elm::win::icon_object_set(::evas::object icon_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_icon_object_set(::efl::eolian::to_c(icon_)));
}

inline int eo_cxx::elm::win::quickpanel_priority_minor_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_quickpanel_priority_minor_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::win::quickpanel_priority_minor_set(int priority_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_quickpanel_priority_minor_set(priority_));
}

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

inline void eo_cxx::elm::win::sticky_set(bool sticky_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_sticky_set(::efl::eolian::to_c(sticky_)));
}

inline Elm_Win_Keyboard_Mode eo_cxx::elm::win::keyboard_mode_get() const
{
   Elm_Win_Keyboard_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_keyboard_mode_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::win::keyboard_mode_set(Elm_Win_Keyboard_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_keyboard_mode_set(mode_));
}

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

inline void eo_cxx::elm::win::focus_highlight_animate_set(bool animate_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_focus_highlight_animate_set(::efl::eolian::to_c(animate_)));
}

inline double eo_cxx::elm::win::aspect_get() const
{
   double _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_aspect_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::win::aspect_set(double aspect_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_aspect_set(aspect_));
}

inline int eo_cxx::elm::win::quickpanel_priority_major_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_quickpanel_priority_major_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::win::quickpanel_priority_major_set(int priority_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_quickpanel_priority_major_set(priority_));
}

inline Elm_Win_Indicator_Opacity_Mode eo_cxx::elm::win::indicator_opacity_get() const
{
   Elm_Win_Indicator_Opacity_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_indicator_opacity_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::win::indicator_opacity_set(Elm_Win_Indicator_Opacity_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_indicator_opacity_set(mode_));
}

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

inline void eo_cxx::elm::win::demand_attention_set(bool demand_attention_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_demand_attention_set(::efl::eolian::to_c(demand_attention_)));
}

inline int eo_cxx::elm::win::wm_preferred_rotation_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_wm_preferred_rotation_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::win::wm_preferred_rotation_set(int rotation_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_wm_preferred_rotation_set(rotation_));
}

inline int eo_cxx::elm::win::layer_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_layer_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::win::layer_set(int layer_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_layer_set(layer_));
}

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

inline void eo_cxx::elm::win::profile_set(::efl::eina::string_view profile_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_profile_set(::efl::eolian::to_c(profile_)));
}

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

inline void eo_cxx::elm::win::shaped_set(bool shaped_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_shaped_set(::efl::eolian::to_c(shaped_)));
}

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

inline void eo_cxx::elm::win::fullscreen_set(bool fullscreen_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_fullscreen_set(::efl::eolian::to_c(fullscreen_)));
}

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

inline void eo_cxx::elm::win::wm_manual_rotation_done_set(bool set_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_wm_manual_rotation_done_set(::efl::eolian::to_c(set_)));
}

inline Elm_Win_Indicator_Mode eo_cxx::elm::win::indicator_mode_get() const
{
   Elm_Win_Indicator_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_indicator_mode_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::win::indicator_mode_set(Elm_Win_Indicator_Mode mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_indicator_mode_set(mode_));
}

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

inline void eo_cxx::elm::win::conformant_set(bool conformant_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_conformant_set(::efl::eolian::to_c(conformant_)));
}

inline void eo_cxx::elm::win::size_base_get(int* w_, int* h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_size_base_get(w_, h_));
}

inline void eo_cxx::elm::win::size_base_set(int w_, int h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_size_base_set(w_, h_));
}

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

inline void eo_cxx::elm::win::quickpanel_set(bool quickpanel_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_quickpanel_set(::efl::eolian::to_c(quickpanel_)));
}

inline void eo_cxx::elm::win::rotation_with_resize_set(int rotation_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_rotation_with_resize_set(rotation_));
}

inline void eo_cxx::elm::win::prop_focus_skip_set(bool skip_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_prop_focus_skip_set(::efl::eolian::to_c(skip_)));
}

inline void eo_cxx::elm::win::screen_position_get(int* x_, int* y_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_screen_position_get(x_, y_));
}

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

inline Ecore_X_Window eo_cxx::elm::win::xwindow_get() const
{
   Ecore_X_Window _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_xwindow_get());
   return _tmp_ret;
}

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

inline void eo_cxx::elm::win::screen_size_get(int* x_, int* y_, int* w_, int* h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_screen_size_get(x_, y_, w_, h_));
}

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

inline Ecore_Wl2_Window * eo_cxx::elm::win::wl_window_get() const
{
   Ecore_Wl2_Window * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_wl_window_get());
   return _tmp_ret;
}

inline Ecore_Cocoa_Window * eo_cxx::elm::win::cocoa_window_get() const
{
   Ecore_Cocoa_Window * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_cocoa_window_get());
   return _tmp_ret;
}

inline Ecore_Win32_Window * eo_cxx::elm::win::win32_window_get() const
{
   Ecore_Win32_Window * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_win32_window_get());
   return _tmp_ret;
}

inline Ecore_Window eo_cxx::elm::win::window_id_get() const
{
   Ecore_Window _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_window_id_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::win::screen_dpi_get(int* xdpi_, int* ydpi_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_screen_dpi_get(xdpi_, ydpi_));
}

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

inline void eo_cxx::elm::win::name_set(::efl::eina::optional< ::efl::eina::string_view > name_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_name_set(::efl::eolian::to_c(name_)));
}

inline Elm_Win_Type eo_cxx::elm::win::type_get() const
{
   Elm_Win_Type _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_type_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::win::type_set(Elm_Win_Type type_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_type_set(type_));
}

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

inline void eo_cxx::elm::win::noblank_set(bool noblank_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_noblank_set(::efl::eolian::to_c(noblank_)));
}

inline void * eo_cxx::elm::win::trap_data_get() const
{
   void * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_win_trap_data_get());
   return _tmp_ret;
}

#ifdef WIN_PROTECTED
inline void eo_cxx::elm::win::fake_canvas_set(Ecore_Evas * oee_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_win_fake_canvas_set(oee_));
}
#endif

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

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

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

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

template <typename T>
bool elm_win_socket_listen_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * svcname_, int svcnum_, Eina_Bool svcsys_)
{
   try
      {
         return static_cast<T*>(self->this_)->socket_listen(::efl::eolian::to_cxx<::efl::eina::string_view>(svcname_, std::tuple<std::false_type>()), svcnum_, ::efl::eolian::to_cxx<bool>(svcsys_, 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_win_illume_command_send_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Illume_Command command_, void * params_)
{
   try
      {
         static_cast<T*>(self->this_)->illume_command_send(command_, params_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

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

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

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

template <typename T>
bool elm_win_keygrab_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * key_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_, int proirity_, Elm_Win_Keygrab_Mode grab_mode_)
{
   try
      {
         return static_cast<T*>(self->this_)->keygrab_set(::efl::eolian::to_cxx<::efl::eina::string_view>(key_, std::tuple<std::false_type>()), modifiers_, not_modifiers_, proirity_, grab_mode_);
      }
   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_win_keygrab_unset_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * key_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_)
{
   try
      {
         return static_cast<T*>(self->this_)->keygrab_unset(::efl::eolian::to_cxx<::efl::eina::string_view>(key_, std::tuple<std::false_type>()), modifiers_, not_modifiers_);
      }
   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_win_keyboard_win_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->keyboard_win_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_win_keyboard_win_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool is_keyboard_)
{
   try
      {
         static_cast<T*>(self->this_)->keyboard_win_set(::efl::eolian::to_cxx<bool>(is_keyboard_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

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

template <typename T>
bool elm_win_wm_available_rotations_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, int ** rotations_, unsigned int* count_)
{
   try
      {
         return static_cast<T*>(self->this_)->wm_available_rotations_get(rotations_, count_);
      }
   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_win_wm_available_rotations_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const int * rotations_, unsigned int count_)
{
   try
      {
         static_cast<T*>(self->this_)->wm_available_rotations_set(rotations_, count_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

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

template <typename T>
::efl::eina::string_view elm_win_icon_name_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->icon_name_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_win_icon_name_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * icon_name_)
{
   try
      {
         static_cast<T*>(self->this_)->icon_name_set(::efl::eolian::to_cxx<::efl::eina::string_view>(icon_name_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

template <typename T>
::efl::eina::string_view elm_win_role_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->role_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_win_role_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * role_)
{
   try
      {
         static_cast<T*>(self->this_)->role_set(::efl::eolian::to_cxx<::efl::eina::string_view>(role_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

template <typename T>
::efl::eina::optional< ::efl::eina::string_view > elm_win_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::optional< ::efl::eina::string_view >>(_tmp_ret, std::tuple<std::false_type>());
      }
}

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

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

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

template <typename T>
bool elm_win_available_profiles_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, char *** profiles_, unsigned int* count_)
{
   try
      {
         return static_cast<T*>(self->this_)->available_profiles_get(profiles_, count_);
      }
   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_win_available_profiles_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char ** profiles_, unsigned int count_)
{
   try
      {
         static_cast<T*>(self->this_)->available_profiles_set(profiles_, count_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

template <typename T>
::efl::eina::string_view elm_win_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 ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
::efl::eina::string_view elm_win_profile_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->profile_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_win_profile_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * profile_)
{
   try
      {
         static_cast<T*>(self->this_)->profile_set(::efl::eolian::to_cxx<::efl::eina::string_view>(profile_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
bool elm_win_wm_rotation_supported_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->wm_rotation_supported_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>
Ecore_X_Window elm_win_xwindow_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->xwindow_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Ecore_X_Window _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
bool elm_win_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_win_screen_size_get_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_)->screen_size_get(x_, y_, w_, h_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::evas::object elm_win_main_menu_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->main_menu_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>
Ecore_Wl2_Window * elm_win_wl_window_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->wl_window_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Ecore_Wl2_Window * _tmp_ret{};
         return _tmp_ret;
      }
}

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

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

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

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

template <typename T>
::evas::object elm_win_inlined_image_object_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->inlined_image_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>
void elm_win_name_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * name_)
{
   try
      {
         static_cast<T*>(self->this_)->name_set(::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(name_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

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

#ifdef WIN_PROTECTED
template <typename T>
void elm_win_fake_canvas_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Ecore_Evas * oee_)
{
   try
      {
         static_cast<T*>(self->this_)->fake_canvas_set(oee_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}
#endif

namespace efl { namespace eo { namespace detail {

template<>
struct operations< ::elm::win >
{
   template <typename T>
   struct type
         : virtual operations< ::elm::widget >::template type<T>
         , virtual operations< ::elm_interface_atspi_window >::template type<T>
         , virtual operations< ::elm_interface_atspi_widget_action >::template type<T>
   {
      virtual void wm_manual_rotation_done_manual()
      {

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

      virtual bool socket_listen(::efl::eina::string_view svcname_, int svcnum_, bool svcsys_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual void illume_command_send(Elm_Illume_Command command_, void * params_)
      {

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

      virtual void activate()
      {

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

      virtual void resize_object_add(::evas::object subobj_)
      {

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

      virtual void raise()
      {

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

      virtual void lower()
      {

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

      virtual void resize_object_del(::evas::object subobj_)
      {

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

      virtual void center(bool h_, bool v_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_win_center(::efl::eolian::to_c(h_), ::efl::eolian::to_c(v_)));
      }

      virtual bool keygrab_set(::efl::eina::string_view key_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_, int proirity_, Elm_Win_Keygrab_Mode grab_mode_)
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_win_keygrab_set(::efl::eolian::to_c(key_), modifiers_, not_modifiers_, proirity_, grab_mode_));
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool keygrab_unset(::efl::eina::string_view key_, Evas_Modifier_Mask modifiers_, Evas_Modifier_Mask not_modifiers_)
      {
         Eina_Bool _tmp_ret = {};

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

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

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

      virtual void keyboard_win_set(bool is_keyboard_)
      {

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

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

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

      virtual void autodel_set(bool autodel_)
      {

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

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

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

      virtual void autohide_set(bool autohide_)
      {

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

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

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

      virtual void override_set(bool override_)
      {

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

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

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

      virtual void iconified_set(bool iconified_)
      {

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

      virtual bool wm_available_rotations_get(int ** rotations_, unsigned int* count_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual void wm_available_rotations_set(const int * rotations_, unsigned int count_)
      {

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

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

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

      virtual void quickpanel_zone_set(int zone_)
      {

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

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

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

      virtual void maximized_set(bool maximized_)
      {

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

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

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

      virtual void modal_set(bool modal_)
      {

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

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

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

      virtual void icon_name_set(::efl::eina::string_view icon_name_)
      {

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

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

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

      virtual void withdrawn_set(bool withdrawn_)
      {

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

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

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

      virtual void role_set(::efl::eina::string_view role_)
      {

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

      virtual void size_step_get(int* w_, int* h_)
      {

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

      virtual void size_step_set(int w_, int h_)
      {

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

      virtual ::efl::eina::optional< ::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_win_focus_highlight_style_get());
            return ::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void focus_highlight_style_set(::efl::eina::optional< ::efl::eina::string_view > style_)
      {

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

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

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

      virtual void borderless_set(bool borderless_)
      {

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

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

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

      virtual void screen_constrain_set(bool constrain_)
      {

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

      virtual bool available_profiles_get(char *** profiles_, unsigned int* count_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual void available_profiles_set(const char ** profiles_, unsigned int count_)
      {

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

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

      virtual void focus_highlight_enabled_set(bool enabled_)
      {

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

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

      virtual void title_set(::efl::eina::string_view title_)
      {

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

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

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

      virtual void alpha_set(bool alpha_)
      {

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

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

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

      virtual void urgent_set(bool urgent_)
      {

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

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

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

      virtual void rotation_set(int rotation_)
      {

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

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

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

      virtual void icon_object_set(::evas::object icon_)
      {

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

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

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

      virtual void quickpanel_priority_minor_set(int priority_)
      {

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

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

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

      virtual void sticky_set(bool sticky_)
      {

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

      virtual Elm_Win_Keyboard_Mode keyboard_mode_get()
      {
         Elm_Win_Keyboard_Mode _tmp_ret = {};

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

      virtual void keyboard_mode_set(Elm_Win_Keyboard_Mode mode_)
      {

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

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

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

      virtual void focus_highlight_animate_set(bool animate_)
      {

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

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

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

      virtual void aspect_set(double aspect_)
      {

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

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

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

      virtual void quickpanel_priority_major_set(int priority_)
      {

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

      virtual Elm_Win_Indicator_Opacity_Mode indicator_opacity_get()
      {
         Elm_Win_Indicator_Opacity_Mode _tmp_ret = {};

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

      virtual void indicator_opacity_set(Elm_Win_Indicator_Opacity_Mode mode_)
      {

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

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

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

      virtual void demand_attention_set(bool demand_attention_)
      {

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

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

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

      virtual void wm_preferred_rotation_set(int rotation_)
      {

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

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

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

      virtual void layer_set(int layer_)
      {

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

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

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

      virtual void profile_set(::efl::eina::string_view profile_)
      {

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

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

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

      virtual void shaped_set(bool shaped_)
      {

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

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

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

      virtual void fullscreen_set(bool fullscreen_)
      {

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

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

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

      virtual void wm_manual_rotation_done_set(bool set_)
      {

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

      virtual Elm_Win_Indicator_Mode indicator_mode_get()
      {
         Elm_Win_Indicator_Mode _tmp_ret = {};

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

      virtual void indicator_mode_set(Elm_Win_Indicator_Mode mode_)
      {

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

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

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

      virtual void conformant_set(bool conformant_)
      {

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

      virtual void size_base_get(int* w_, int* h_)
      {

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

      virtual void size_base_set(int w_, int h_)
      {

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

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

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

      virtual void quickpanel_set(bool quickpanel_)
      {

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

      virtual void rotation_with_resize_set(int rotation_)
      {

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

      virtual void prop_focus_skip_set(bool skip_)
      {

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

      virtual void screen_position_get(int* x_, int* y_)
      {

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

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

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

      virtual Ecore_X_Window xwindow_get()
      {
         Ecore_X_Window _tmp_ret = {};

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

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

      virtual void screen_size_get(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_win_screen_size_get(x_, y_, w_, h_));
      }

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

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

      virtual Ecore_Wl2_Window * wl_window_get()
      {
         Ecore_Wl2_Window * _tmp_ret = {};

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

      virtual Ecore_Cocoa_Window * cocoa_window_get()
      {
         Ecore_Cocoa_Window * _tmp_ret = {};

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

      virtual Ecore_Win32_Window * win32_window_get()
      {
         Ecore_Win32_Window * _tmp_ret = {};

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

      virtual Ecore_Window window_id_get()
      {
         Ecore_Window _tmp_ret = {};

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

      virtual void screen_dpi_get(int* xdpi_, int* ydpi_)
      {

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

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

      virtual void name_set(::efl::eina::optional< ::efl::eina::string_view > name_)
      {

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

      virtual Elm_Win_Type type_get()
      {
         Elm_Win_Type _tmp_ret = {};

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

      virtual void type_set(Elm_Win_Type type_)
      {

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

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

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

      virtual void noblank_set(bool noblank_)
      {

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

      virtual void * trap_data_get()
      {
         void * _tmp_ret = {};

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

#ifdef WIN_PROTECTED
      virtual void fake_canvas_set(Ecore_Evas * oee_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_win_fake_canvas_set(oee_));
      }
#endif

   };
};


template<>
struct operation_description_class_size< ::elm::win >
{
   static constexpr int value = 
#if defined(WIN_PROTECTED) && defined(WIN_BETA)
      114
#elif defined(WIN_PROTECTED)
      114
#elif defined(WIN_BETA)
      113
#else
      113
#endif
      + operation_description_class_size<::elm::widget >::value      + operation_description_class_size<::elm_interface_atspi_window >::value      + operation_description_class_size<::elm_interface_atspi_widget_action >::value;
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#ifdef WIN_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::elm_win_fake_canvas_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_obj_win_fake_canvas_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

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

} } }

/// @endcond

