#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"
}


namespace evas {

struct out
      : efl::eo::base
{
   /// @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::base(eo)
   {}

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

   /// @brief Call the object's constructor.
   /// Should not be used with #eo_do. Only use it with #eo_do_super.
   ///
   out(efl::eo::parent_type _p = (efl::eo::parent = nullptr))
      : out(_c0(_p))
   {}

   /// @brief Copy Constructor.
   ///
   out(out const& other)
      : efl::eo::base(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
   {
      eo_do(_eo_ptr(), ::evas_out_view_get(x_, y_, w_, h_));
   }

   /// @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
   {
      eo_do(_eo_ptr(), ::evas_out_view_set(x_, y_, w_, h_));
   }

   /// @brief Gets the engine specific output parameters for a given output.
   ///
   /// @param info The engine parameters
   ///
   Evas_Engine_Info * engine_info_get() const
   {
      Evas_Engine_Info * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_out_engine_info_get());
      return _tmp_ret;
   }

   /// @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
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_out_engine_info_set(info_));
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

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

private:
   static Eo* _c0(efl::eo::parent_type _p)
   {
      return eo_add_ref(EVAS_OUT_CLASS, _p._eo_raw, eo_constructor());
   }

};
} 

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_)
{
   static_cast<T*>(self->this_)->view_get(x_, y_, w_, h_);
}

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_)
{
   static_cast<T*>(self->this_)->view_set(x_, y_, w_, h_);
}

template <typename T>
Evas_Engine_Info * evas_out_engine_info_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->engine_info_get();
}

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_)
{
   return static_cast<T*>(self->this_)->engine_info_set(info_);
}

namespace efl { namespace eo { namespace detail {

template<>
struct operations< evas::out >
{
   template <typename T>
   struct type
   {
      virtual void view_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_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(static_cast<T*>(this)->_eo_ptr(),
               static_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(static_cast<T*>(this)->_eo_ptr(),
               static_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(static_cast<T*>(this)->_eo_ptr(),
               static_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;
};

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;

   return 0;
}
inline void
call_constructor(tag< evas::out >
               , Eo* eo, Eo_Class const* cls EINA_UNUSED,
               args_class<evas::out, ::std::tuple<> > const& args)
{
   (void)args;
   eo_do_super(eo, cls, ::eo_constructor());
}

inline void
call_constructor(tag< evas::out >
               , Eo* eo, Eo_Class const* cls EINA_UNUSED,
               args_class<evas::out, ::std::tuple<efl::eo::parent_type> > const& args)
{
   eo_do_super(eo, cls, ::eo_constructor());
   eo_do(eo, ::eo_parent_set(args.get<0>()._eo_raw));
}

template<>
struct extension_inheritance< evas::out>
{
   template <typename U>
   struct type
   {
      operator evas::out() const
      {
         return evas::out(eo_ref(static_cast<U const*>(this)->_eo_ptr()));
      }

      void view_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_out_view_get(x_, y_, w_, h_));
      }

      void view_set(Evas_Coord x_, Evas_Coord y_, Evas_Coord w_, Evas_Coord h_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_out_view_set(x_, y_, w_, h_));
      }

      Evas_Engine_Info * engine_info_get()
      {
         Evas_Engine_Info * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_out_engine_info_get());
            return _tmp_ret;
      }

      bool engine_info_set(Evas_Engine_Info * info_)
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_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_Class const* get_eo_class(tag<evas::out>)
{
   return (EVAS_OUT_CLASS);
}

} } }
#endif // EFL_GENERATED_EVAS_OUT_HH

