/// @cond EO_CXX_EO_IMPL

inline bool elm::toolbar_item::icon_memfile_set(const void * img_, size_t size_, ::efl::eina::string_view format_, ::efl::eina::string_view key_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_icon_memfile_set(img_, size_, ::efl::eolian::to_c(format_), ::efl::eolian::to_c(key_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool elm::toolbar_item::icon_file_set(::efl::eina::string_view file_, ::efl::eina::string_view key_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_icon_file_set(::efl::eolian::to_c(file_), ::efl::eolian::to_c(key_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline Elm_Toolbar_Item_State * elm::toolbar_item::state_add(::efl::eina::string_view icon_, ::efl::eina::string_view label_, Evas_Smart_Cb func_, const void * data_) const
{
   Elm_Toolbar_Item_State * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_state_add(::efl::eolian::to_c(icon_), ::efl::eolian::to_c(label_), func_, data_));
   return _tmp_ret;
}

inline bool elm::toolbar_item::state_del(Elm_Toolbar_Item_State * state_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_state_del(state_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline Elm_Toolbar_Item_State * elm::toolbar_item::state_next() const
{
   Elm_Toolbar_Item_State * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_state_next());
   return _tmp_ret;
}

inline Elm_Toolbar_Item_State * elm::toolbar_item::state_prev() const
{
   Elm_Toolbar_Item_State * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_state_prev());
   return _tmp_ret;
}

inline void elm::toolbar_item::show(Elm_Toolbar_Item_Scrollto_Type scrollto_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_toolbar_item_show(scrollto_));
}

inline void elm::toolbar_item::bring_in(Elm_Toolbar_Item_Scrollto_Type scrollto_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_toolbar_item_bring_in(scrollto_));
}

inline void elm::toolbar_item::menu_set(bool menu_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_toolbar_item_menu_set(::efl::eolian::to_c(menu_)));
}

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

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

inline int elm::toolbar_item::priority_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_priority_get());
   return _tmp_ret;
}

inline void elm::toolbar_item::priority_set(int priority_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_toolbar_item_priority_set(priority_));
}

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

inline void elm::toolbar_item::selected_set(bool selected_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_toolbar_item_selected_set(::efl::eolian::to_c(selected_)));
}

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

inline void elm::toolbar_item::icon_set(::efl::eina::string_view icon_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_toolbar_item_icon_set(::efl::eolian::to_c(icon_)));
}

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

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

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

inline void elm::toolbar_item::separator_set(bool separator_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_toolbar_item_separator_set(::efl::eolian::to_c(separator_)));
}

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

inline Elm_Toolbar_Item_State * elm::toolbar_item::state_get() const
{
   Elm_Toolbar_Item_State * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_state_get());
   return _tmp_ret;
}

inline bool elm::toolbar_item::state_set(Elm_Toolbar_Item_State * state_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_state_set(state_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool eo_cxx::elm::toolbar_item::icon_memfile_set(const void * img_, size_t size_, ::efl::eina::string_view format_, ::efl::eina::string_view key_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_icon_memfile_set(img_, size_, ::efl::eolian::to_c(format_), ::efl::eolian::to_c(key_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool eo_cxx::elm::toolbar_item::icon_file_set(::efl::eina::string_view file_, ::efl::eina::string_view key_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_icon_file_set(::efl::eolian::to_c(file_), ::efl::eolian::to_c(key_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline Elm_Toolbar_Item_State * eo_cxx::elm::toolbar_item::state_add(::efl::eina::string_view icon_, ::efl::eina::string_view label_, Evas_Smart_Cb func_, const void * data_) const
{
   Elm_Toolbar_Item_State * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_state_add(::efl::eolian::to_c(icon_), ::efl::eolian::to_c(label_), func_, data_));
   return _tmp_ret;
}

inline bool eo_cxx::elm::toolbar_item::state_del(Elm_Toolbar_Item_State * state_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_state_del(state_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline Elm_Toolbar_Item_State * eo_cxx::elm::toolbar_item::state_next() const
{
   Elm_Toolbar_Item_State * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_state_next());
   return _tmp_ret;
}

inline Elm_Toolbar_Item_State * eo_cxx::elm::toolbar_item::state_prev() const
{
   Elm_Toolbar_Item_State * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_state_prev());
   return _tmp_ret;
}

inline void eo_cxx::elm::toolbar_item::show(Elm_Toolbar_Item_Scrollto_Type scrollto_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_toolbar_item_show(scrollto_));
}

inline void eo_cxx::elm::toolbar_item::bring_in(Elm_Toolbar_Item_Scrollto_Type scrollto_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_toolbar_item_bring_in(scrollto_));
}

inline void eo_cxx::elm::toolbar_item::menu_set(bool menu_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_toolbar_item_menu_set(::efl::eolian::to_c(menu_)));
}

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

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

inline int eo_cxx::elm::toolbar_item::priority_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_priority_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::toolbar_item::priority_set(int priority_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_toolbar_item_priority_set(priority_));
}

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

inline void eo_cxx::elm::toolbar_item::selected_set(bool selected_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_toolbar_item_selected_set(::efl::eolian::to_c(selected_)));
}

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

inline void eo_cxx::elm::toolbar_item::icon_set(::efl::eina::string_view icon_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_toolbar_item_icon_set(::efl::eolian::to_c(icon_)));
}

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

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

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

inline void eo_cxx::elm::toolbar_item::separator_set(bool separator_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_toolbar_item_separator_set(::efl::eolian::to_c(separator_)));
}

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

inline Elm_Toolbar_Item_State * eo_cxx::elm::toolbar_item::state_get() const
{
   Elm_Toolbar_Item_State * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_state_get());
   return _tmp_ret;
}

inline bool eo_cxx::elm::toolbar_item::state_set(Elm_Toolbar_Item_State * state_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_toolbar_item_state_set(state_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

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

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

template <typename T>
bool elm_toolbar_item_icon_memfile_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const void * img_, size_t size_, const char * format_, const char * key_)
{
   try
      {
         return static_cast<T*>(self->this_)->icon_memfile_set(img_, size_, ::efl::eolian::to_cxx<::efl::eina::string_view>(format_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(key_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_Bool _tmp_ret{};
         return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
bool elm_toolbar_item_icon_file_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * file_, const char * key_)
{
   try
      {
         return static_cast<T*>(self->this_)->icon_file_set(::efl::eolian::to_cxx<::efl::eina::string_view>(file_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(key_, 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>
Elm_Toolbar_Item_State * elm_toolbar_item_state_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * icon_, const char * label_, Evas_Smart_Cb func_, const void * data_)
{
   try
      {
         return static_cast<T*>(self->this_)->state_add(::efl::eolian::to_cxx<::efl::eina::string_view>(icon_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(label_, std::tuple<std::false_type>()), func_, data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Toolbar_Item_State * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
bool elm_toolbar_item_state_del_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Toolbar_Item_State * state_)
{
   try
      {
         return static_cast<T*>(self->this_)->state_del(state_);
      }
   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>
Elm_Toolbar_Item_State * elm_toolbar_item_state_next_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->state_next();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Toolbar_Item_State * _tmp_ret{};
         return _tmp_ret;
      }
}

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
::evas::object elm_toolbar_item_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() );
         Evas_Object * _tmp_ret{};
         return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }
}

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

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

template <typename T>
bool elm_toolbar_item_state_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Toolbar_Item_State * state_)
{
   try
      {
         return static_cast<T*>(self->this_)->state_set(state_);
      }
   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>());
      }
}

namespace efl { namespace eo { namespace detail {

template<>
struct operations< ::elm::toolbar_item >
{
   template <typename T>
   struct type
         : virtual operations< ::elm::widget_item >::template type<T>
   {
      virtual bool icon_memfile_set(const void * img_, size_t size_, ::efl::eina::string_view format_, ::efl::eina::string_view key_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual bool icon_file_set(::efl::eina::string_view file_, ::efl::eina::string_view key_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual Elm_Toolbar_Item_State * state_add(::efl::eina::string_view icon_, ::efl::eina::string_view label_, Evas_Smart_Cb func_, const void * data_)
      {
         Elm_Toolbar_Item_State * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_toolbar_item_state_add(::efl::eolian::to_c(icon_), ::efl::eolian::to_c(label_), func_, data_));
            return _tmp_ret;
      }

      virtual bool state_del(Elm_Toolbar_Item_State * state_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual Elm_Toolbar_Item_State * state_next()
      {
         Elm_Toolbar_Item_State * _tmp_ret = {};

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

      virtual Elm_Toolbar_Item_State * state_prev()
      {
         Elm_Toolbar_Item_State * _tmp_ret = {};

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

      virtual void show(Elm_Toolbar_Item_Scrollto_Type scrollto_)
      {

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

      virtual void bring_in(Elm_Toolbar_Item_Scrollto_Type scrollto_)
      {

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

      virtual void menu_set(bool menu_)
      {

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

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

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

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

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

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

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

      virtual void priority_set(int priority_)
      {

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

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

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

      virtual void selected_set(bool selected_)
      {

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

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

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

      virtual void icon_set(::efl::eina::string_view icon_)
      {

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

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

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

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

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

      virtual void separator_set(bool separator_)
      {

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

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

      virtual Elm_Toolbar_Item_State * state_get()
      {
         Elm_Toolbar_Item_State * _tmp_ret = {};

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

      virtual bool state_set(Elm_Toolbar_Item_State * state_)
      {
         Eina_Bool _tmp_ret = {};

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

   };
};


template<>
struct operation_description_class_size< ::elm::toolbar_item >
{
   static constexpr int value = 
#if defined(TOOLBAR_ITEM_PROTECTED) && defined(TOOLBAR_ITEM_BETA)
      24
#elif defined(TOOLBAR_ITEM_PROTECTED)
      24
#elif defined(TOOLBAR_ITEM_BETA)
      24
#else
      24
#endif
      + operation_description_class_size<::elm::widget_item >::value;
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

} } }

/// @endcond

