#ifndef EFL_GENERATED_EVAS_OUT_HH
#define EFL_GENERATED_EVAS_OUT_HH

extern "C"
{
#include <Efl.h>
}
#include <Eo.hh>

#include <eo_cxx_interop.hh>

extern "C"
{
#include "evas_out.eo.h"
}

#include "eo_base.eo.hh"

namespace evas {

struct out;

}

namespace eo_cxx {

namespace evas {

struct out
{
   /// @brief Gets the viewport region of the canvas that the output displays
   ///
   /// @param x 
   /// @param y 
   /// @param w 
   /// @param h 
   ///
   void view_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const;


   /// @brief Sets the viewport region of the canvas that the output displays This sets both the viewport region in the canvas that displays on the given output, but also the viewport size will match the output resolution 1:1.
   ///
   /// @param x 
   /// @param y 
   /// @param w 
   /// @param h 
   ///
   void view_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_) const;


   /// @brief Gets the engine specific output parameters for a given output.
   ///
   /// @param info The engine parameters
   ///
   Evas_Engine_Info * engine_info_get() const;


   /// @brief Sets the engine specific output parameters for a given output.
   ///
   /// @param info The engine parameters
   ///
   bool engine_info_set(Evas_Engine_Info * info_) const;



   static Eo_Class const* _eo_class()
   {
      return(EVAS_OUT_CLASS);
   }

   operator ::evas::out() const;
   operator ::evas::out&();
   operator ::evas::out const&() const;

   template <typename D>
   struct address_of
   {
      operator ::evas::out*() const { return static_cast<::evas::out*>(static_cast<D const*>(this)->p); }
      operator ::evas::out const*() const { return static_cast<::evas::out const*>(static_cast<D const*>(this)->p); }
   };

   template <typename D>
   struct address_const_of
   {
      operator ::evas::out const*() const { return static_cast<::evas::out const*>(static_cast<D const*>(this)->p); }
   };

private:
   Eo* _concrete_eo_ptr() const
   {
      return static_cast<::efl::eo::concrete const*>(static_cast<void const*>(this))->_eo_ptr();
   }

};

}

}

namespace evas {

struct out
      : ::efl::eo::concrete
      , ::eo_cxx::eo::base
{
   out(::efl::eo::parent_type _p = (::efl::eo::parent = nullptr))
      : out(_ctors_call(_p))
   {}

   /// @brief Eo Constructor.
   ///
   /// Constructs the object from an Eo* pointer stealing its ownership.
   ///
   /// @param eo The Eo object pointer.
   ///
   explicit out(Eo* eo)
      : ::efl::eo::concrete(eo)
   {}

   /// @brief nullptr_t Constructor.
   ///
   /// Constructs an empty (null) object.
   ///
   explicit out(std::nullptr_t)
      : ::efl::eo::concrete(nullptr)
   {}

   /// @brief Copy Constructor.
   ///
   out(out const& other)
      : out(eo_ref(other._eo_ptr()))
   {}

   ~out() {}

   /// @brief Gets the viewport region of the canvas that the output displays
   ///
   /// @param x 
   /// @param y 
   /// @param w 
   /// @param h 
   ///
   void view_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const;


   /// @brief Sets the viewport region of the canvas that the output displays This sets both the viewport region in the canvas that displays on the given output, but also the viewport size will match the output resolution 1:1.
   ///
   /// @param x 
   /// @param y 
   /// @param w 
   /// @param h 
   ///
   void view_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_) const;


   /// @brief Gets the engine specific output parameters for a given output.
   ///
   /// @param info The engine parameters
   ///
   Evas_Engine_Info * engine_info_get() const;


   /// @brief Sets the engine specific output parameters for a given output.
   ///
   /// @param info The engine parameters
   ///
   bool engine_info_set(Evas_Engine_Info * info_) const;



   static Eo_Class const* _eo_class()
   {
      return(EVAS_OUT_CLASS);
   }

   struct address_of
      : ::eo_cxx::evas::out::address_of<address_of>
      , ::eo_cxx::eo::base::address_of<address_of>
      , ::efl::eo::detail::concrete_address_of
   {
      explicit address_of(::evas::out* p)
         : ::efl::eo::detail::concrete_address_of(p)
      {}
   };
   address_of operator&() { return address_of(this); }

   struct address_const_of
      : ::eo_cxx::evas::out::address_const_of<address_const_of>
      , ::eo_cxx::eo::base::address_const_of<address_const_of>
      , ::efl::eo::detail::concrete_address_const_of
   {
      explicit address_const_of(::evas::out const* p)
         : ::efl::eo::detail::concrete_address_const_of(p)
      {}
   };
   address_const_of operator&() const { return address_const_of(this); }

private:
   static Eo* _ctors_call(::efl::eo::parent_type _p)
   {
      Eo* _ret_eo = eo_add_ref(EVAS_OUT_CLASS, _p._eo_raw, );

      return _ret_eo;
   }

      Eo* _concrete_eo_ptr() const { return _eo_ptr(); }
};

static_assert(sizeof(::evas::out) == sizeof(Eo*), "");
static_assert(std::is_standard_layout<::evas::out>::value, "");

}

inline void evas::out::view_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
{
   eo_do(_concrete_eo_ptr(), ::evas_out_view_get(x_, y_, w_, h_));
}


inline void evas::out::view_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_) const
{
   eo_do(_concrete_eo_ptr(), ::evas_out_view_set(x_, y_, w_, h_));
}


inline Evas_Engine_Info * evas::out::engine_info_get() const
{
   Evas_Engine_Info * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::evas_out_engine_info_get());
   return _tmp_ret;
}


inline bool evas::out::engine_info_set(Evas_Engine_Info * info_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::evas_out_engine_info_set(info_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}


inline void eo_cxx::evas::out::view_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
{
   eo_do(_concrete_eo_ptr(), ::evas_out_view_get(x_, y_, w_, h_));
}


inline void eo_cxx::evas::out::view_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_) const
{
   eo_do(_concrete_eo_ptr(), ::evas_out_view_set(x_, y_, w_, h_));
}


inline Evas_Engine_Info * eo_cxx::evas::out::engine_info_get() const
{
   Evas_Engine_Info * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::evas_out_engine_info_get());
   return _tmp_ret;
}


inline bool eo_cxx::evas::out::engine_info_set(Evas_Engine_Info * info_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::evas_out_engine_info_set(info_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}


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

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

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

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

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

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

template <typename T>
bool evas_out_engine_info_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Engine_Info * info_)
{
   bool _tmp_ret{};
   try
      {
         _tmp_ret = static_cast<T*>(self->this_)->engine_info_set(info_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
   return _tmp_ret;
}

namespace efl { namespace eo { namespace detail {

template<>
struct operations< ::evas::out >
{
   template <typename T>
   struct type
         : virtual operations< ::eo::base >::template type<T>
   {
      virtual void view_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {

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

      virtual void view_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_)
      {

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

      virtual Evas_Engine_Info * engine_info_get()
      {
         Evas_Engine_Info * _tmp_ret = {};

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

      virtual bool engine_info_set(Evas_Engine_Info * info_)
      {
         Eina_Bool _tmp_ret = {};

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

   };
};


template<>
struct operation_description_class_size< ::evas::out >
{
   static const int value = 4 + operation_description_class_size<::eo::base >::value;
};

template <typename T>
int initialize_operation_description(::efl::eo::detail::tag<::evas::out>
                                 , Eo_Op_Description* ops)
{
   (void)ops;
   ops[0].func = reinterpret_cast<void*>(& ::evas_out_view_get_wrapper<T>);
   ops[0].api_func = reinterpret_cast<void*>(& ::evas_out_view_get);
   ops[0].op = EO_OP_OVERRIDE;
   ops[0].op_type = EO_OP_TYPE_REGULAR;
   ops[0].doc = NULL;

   ops[1].func = reinterpret_cast<void*>(& ::evas_out_view_set_wrapper<T>);
   ops[1].api_func = reinterpret_cast<void*>(& ::evas_out_view_set);
   ops[1].op = EO_OP_OVERRIDE;
   ops[1].op_type = EO_OP_TYPE_REGULAR;
   ops[1].doc = NULL;

   ops[2].func = reinterpret_cast<void*>(& ::evas_out_engine_info_get_wrapper<T>);
   ops[2].api_func = reinterpret_cast<void*>(& ::evas_out_engine_info_get);
   ops[2].op = EO_OP_OVERRIDE;
   ops[2].op_type = EO_OP_TYPE_REGULAR;
   ops[2].doc = NULL;

   ops[3].func = reinterpret_cast<void*>(& ::evas_out_engine_info_set_wrapper<T>);
   ops[3].api_func = reinterpret_cast<void*>(& ::evas_out_engine_info_set);
   ops[3].op = EO_OP_OVERRIDE;
   ops[3].op_type = EO_OP_TYPE_REGULAR;
   ops[3].doc = NULL;

   initialize_operation_description<T>(::efl::eo::detail::tag<::eo::base>(), &ops[4]);
   return 0;
}
inline void
call_constructor(::efl::eo::detail::tag< ::evas::out >
               , Eo* eo, Eo_Class const* cls EINA_UNUSED,
               ::efl::eo::detail::args_class<::evas::out, ::std::tuple<::efl::eo::parent_type> > const& args)
{
   eo_do(eo, ::eo_parent_set(args.get<0>()._eo_raw));
}

inline Eo_Class const* get_eo_class(tag<::evas::out>)
{
   return (EVAS_OUT_CLASS);
}

} } }
#endif // EFL_GENERATED_EVAS_OUT_HH

