// Generated by gtkmmproc -- DO NOT MODIFY!


#include <cluttermm/box-layout.h>
#include <cluttermm/private/box-layout_p.h>

/* Copyright (C) 2011 The cluttermm Development Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <clutter/clutter.h>

namespace Clutter
{

} //namespace Clutter


namespace
{
} // anonymous namespace

// static
GType Glib::Value<Clutter::BoxAlignment>::value_type()
{
  return clutter_box_alignment_get_type();
}


namespace Glib
{

Glib::RefPtr<Clutter::BoxLayout> wrap(ClutterBoxLayout* object, bool take_copy)
{
  return Glib::RefPtr<Clutter::BoxLayout>( dynamic_cast<Clutter::BoxLayout*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
  //We use dynamic_cast<> in case of multiple inheritance.
}

} /* namespace Glib */


namespace Clutter
{


/* The *_Class implementation: */

const Glib::Class& BoxLayout_Class::init()
{
  if(!gtype_) // create the GType if necessary
  {
    // Glib::Class has to know the class init function to clone custom types.
    class_init_func_ = &BoxLayout_Class::class_init_function;

    // This is actually just optimized away, apparently with no harm.
    // Make sure that the parent type has been created.
    //CppClassParent::CppObjectType::get_type();

    // Create the wrapper type, with the same class/instance size as the base type.
    register_derived_type(clutter_box_layout_get_type());

    // Add derived versions of interfaces, if the C type implements any interfaces:

  }

  return *this;
}


void BoxLayout_Class::class_init_function(void* g_class, void* class_data)
{
  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
  CppClassParent::class_init_function(klass, class_data);


}


Glib::ObjectBase* BoxLayout_Class::wrap_new(GObject* object)
{
  return new BoxLayout((ClutterBoxLayout*)object);
}


/* The implementation: */

ClutterBoxLayout* BoxLayout::gobj_copy()
{
  reference();
  return gobj();
}

BoxLayout::BoxLayout(const Glib::ConstructParams& construct_params)
:
  LayoutManager(construct_params)
{

}

BoxLayout::BoxLayout(ClutterBoxLayout* castitem)
:
  LayoutManager((ClutterLayoutManager*)(castitem))
{}


BoxLayout::~BoxLayout()
{}


BoxLayout::CppClassType BoxLayout::boxlayout_class_; // initialize static member

GType BoxLayout::get_type()
{
  return boxlayout_class_.init().get_type();
}


GType BoxLayout::get_base_type()
{
  return clutter_box_layout_get_type();
}


BoxLayout::BoxLayout()
:
  // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  Glib::ObjectBase(0),
  LayoutManager(Glib::ConstructParams(boxlayout_class_.init()))
{
  

}

Glib::RefPtr<BoxLayout> BoxLayout::create()
{
  return Glib::RefPtr<BoxLayout>( new BoxLayout() );
}
void BoxLayout::set_pack_start(bool pack_start)
{
clutter_box_layout_set_pack_start(gobj(), static_cast<int>(pack_start)); 
}

bool BoxLayout::get_pack_start() const
{
  return clutter_box_layout_get_pack_start(const_cast<ClutterBoxLayout*>(gobj()));
}

void BoxLayout::set_spacing(guint spacing)
{
clutter_box_layout_set_spacing(gobj(), spacing); 
}

guint BoxLayout::get_spacing() const
{
  return clutter_box_layout_get_spacing(const_cast<ClutterBoxLayout*>(gobj()));
}

void BoxLayout::set_vertical(bool vertical)
{
clutter_box_layout_set_vertical(gobj(), static_cast<int>(vertical)); 
}

bool BoxLayout::get_vertical() const
{
  return clutter_box_layout_get_vertical(const_cast<ClutterBoxLayout*>(gobj()));
}

void BoxLayout::set_homogeneous(bool homogeneous)
{
clutter_box_layout_set_homogeneous(gobj(), static_cast<int>(homogeneous)); 
}

bool BoxLayout::get_homogeneous() const
{
  return clutter_box_layout_get_homogeneous(const_cast<ClutterBoxLayout*>(gobj()));
}

void BoxLayout::pack(const Glib::RefPtr<Actor>& p1, bool expand, bool x_fill, bool y_fill, BoxAlignment x_align, BoxAlignment y_align)
{
clutter_box_layout_pack(gobj(), Glib::unwrap(p1), static_cast<int>(expand), static_cast<int>(x_fill), static_cast<int>(y_fill), ((ClutterBoxAlignment)(x_align)), ((ClutterBoxAlignment)(y_align))); 
}

void BoxLayout::set_alignment(const Glib::RefPtr<Actor>& child, BoxAlignment x_align, BoxAlignment y_align)
{
clutter_box_layout_set_alignment(gobj(), Glib::unwrap(child), ((ClutterBoxAlignment)(x_align)), ((ClutterBoxAlignment)(y_align))); 
}

void BoxLayout::get_alignment(const Glib::RefPtr<Actor>& child, BoxAlignment & x_align, BoxAlignment & y_align) const
{
clutter_box_layout_get_alignment(const_cast<ClutterBoxLayout*>(gobj()), Glib::unwrap(child), ((ClutterBoxAlignment*) &(x_align)), ((ClutterBoxAlignment*) &(y_align))); 
}

void BoxLayout::set_expand(const Glib::RefPtr<Actor>& child, bool expand)
{
clutter_box_layout_set_expand(gobj(), Glib::unwrap(child), static_cast<int>(expand)); 
}

bool BoxLayout::get_expand(const Glib::RefPtr<Actor>& child) const
{
  return clutter_box_layout_get_expand(const_cast<ClutterBoxLayout*>(gobj()), Glib::unwrap(child));
}

void BoxLayout::set_fill(const Glib::RefPtr<Actor>& child, bool x_fill, bool y_fill)
{
clutter_box_layout_set_fill(gobj(), Glib::unwrap(child), static_cast<int>(x_fill), static_cast<int>(y_fill)); 
}

void BoxLayout::get_fill(const Glib::RefPtr<Actor>& child, bool & x_fill, bool & y_fill) const
{
clutter_box_layout_get_fill(const_cast<ClutterBoxLayout*>(gobj()), Glib::unwrap(child), ((gboolean*) &(x_fill)), ((gboolean*) &(y_fill))); 
}

bool BoxLayout::get_use_animations() const
{
  return clutter_box_layout_get_use_animations(const_cast<ClutterBoxLayout*>(gobj()));
}

void BoxLayout::set_easing_duration(guint msecs)
{
clutter_box_layout_set_easing_duration(gobj(), msecs); 
}

guint BoxLayout::get_easing_duration() const
{
  return clutter_box_layout_get_easing_duration(const_cast<ClutterBoxLayout*>(gobj()));
}

void BoxLayout::set_easing_mode(gulong mode)
{
clutter_box_layout_set_easing_mode(gobj(), mode); 
}

gulong BoxLayout::get_easing_mode() const
{
  return clutter_box_layout_get_easing_mode(const_cast<ClutterBoxLayout*>(gobj()));
}


#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<guint> BoxLayout::property_easing_duration() 
{
  return Glib::PropertyProxy<guint>(this, "easing-duration");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<guint> BoxLayout::property_easing_duration() const
{
  return Glib::PropertyProxy_ReadOnly<guint>(this, "easing-duration");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<unsigned long> BoxLayout::property_easing_mode() 
{
  return Glib::PropertyProxy<unsigned long>(this, "easing-mode");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<unsigned long> BoxLayout::property_easing_mode() const
{
  return Glib::PropertyProxy_ReadOnly<unsigned long>(this, "easing-mode");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<bool> BoxLayout::property_homogeneous() 
{
  return Glib::PropertyProxy<bool>(this, "homogeneous");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<bool> BoxLayout::property_homogeneous() const
{
  return Glib::PropertyProxy_ReadOnly<bool>(this, "homogeneous");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<bool> BoxLayout::property_pack_start() 
{
  return Glib::PropertyProxy<bool>(this, "pack-start");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<bool> BoxLayout::property_pack_start() const
{
  return Glib::PropertyProxy_ReadOnly<bool>(this, "pack-start");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<guint> BoxLayout::property_spacing() 
{
  return Glib::PropertyProxy<guint>(this, "spacing");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<guint> BoxLayout::property_spacing() const
{
  return Glib::PropertyProxy_ReadOnly<guint>(this, "spacing");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<bool> BoxLayout::property_use_animations() 
{
  return Glib::PropertyProxy<bool>(this, "use-animations");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<bool> BoxLayout::property_use_animations() const
{
  return Glib::PropertyProxy_ReadOnly<bool>(this, "use-animations");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy<bool> BoxLayout::property_vertical() 
{
  return Glib::PropertyProxy<bool>(this, "vertical");
}
#endif //GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
Glib::PropertyProxy_ReadOnly<bool> BoxLayout::property_vertical() const
{
  return Glib::PropertyProxy_ReadOnly<bool>(this, "vertical");
}
#endif //GLIBMM_PROPERTIES_ENABLED


} // namespace Clutter


