// Generated by gtkmmproc -- DO NOT MODIFY!


#include <geglmm/operation.h>
#include <geglmm/private/operation_p.h>

/* libgeglmm - a C++ wrapper for libgegl
 *
 * (c) 2008 Hubert Figuiere
 *
 * 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 3 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 GEGL; if not, see <http://www.gnu.org/licenses/>.
 */


#include <geglmm/node.h>

namespace
{
} // anonymous namespace


namespace Glib
{

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

} /* namespace Glib */


namespace Gegl
{


/* The *_Class implementation: */

const Glib::Class& Operation_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_ = &Operation_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(gegl_operation_get_type());

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

  }

  return *this;
}


void Operation_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* Operation_Class::wrap_new(GObject* object)
{
  return new Operation((GeglOperation*)object);
}


/* The implementation: */

GeglOperation* Operation::gobj_copy()
{
  reference();
  return gobj();
}

Operation::Operation(const Glib::ConstructParams& construct_params)
:
  Glib::Object(construct_params)
{

}

Operation::Operation(GeglOperation* castitem)
:
  Glib::Object((GObject*)(castitem))
{}


Operation::~Operation()
{}


Operation::CppClassType Operation::operation_class_; // initialize static member

GType Operation::get_type()
{
  return operation_class_.init().get_type();
}


GType Operation::get_base_type()
{
  return gegl_operation_get_type();
}


Rectangle Operation::get_invalidated_by_change(const Glib::ustring & input_pad, const Rectangle & input_region) const
{
  return Rectangle(gegl_operation_get_invalidated_by_change(const_cast<GeglOperation*>(gobj()), input_pad.c_str(), const_cast<const GeglRectangle*>(input_region.gobj())));
}

Rectangle Operation::get_bounding_box() const
{
  return Rectangle(gegl_operation_get_bounding_box(const_cast<GeglOperation*>(gobj())));
}

Rectangle Operation::source_get_bounding_box(const Glib::ustring & pad_name) const
{
  return Glib::wrap(gegl_operation_source_get_bounding_box(const_cast<GeglOperation*>(gobj()), pad_name.c_str()));
}

Rectangle Operation::get_cached_region(const Rectangle & roi) const
{
  return Rectangle(gegl_operation_get_cached_region(const_cast<GeglOperation*>(gobj()), const_cast<const GeglRectangle*>(roi.gobj())));
}

Rectangle Operation::get_required_for_output(const Glib::ustring & input_pda, const Rectangle & roi) const
{
  return Rectangle(gegl_operation_get_required_for_output(const_cast<GeglOperation*>(gobj()), input_pda.c_str(), const_cast<const GeglRectangle*>(roi.gobj())));
}

Glib::RefPtr<Node> Operation::detect(int x, int y)
{

  Glib::RefPtr<Node> retvalue = Glib::wrap(gegl_operation_detect(gobj(), x, y));
  if(retvalue)
    retvalue->reference(); //The function does not do a ref for us.
  return retvalue;

}

Glib::RefPtr<const Node> Operation::detect(int x, int y) const
{
  return const_cast<Operation*>(this)->detect(x, y);
}

void Operation::attach(const Glib::RefPtr<Node> & node)
{
gegl_operation_attach(gobj(), Glib::unwrap(node)); 
}

void Operation::prepare()
{
gegl_operation_prepare(gobj()); 
}

bool Operation::process(GeglOperationContext * context, const Glib::ustring & output_pad, const Rectangle & result_rect)
{
  return gegl_operation_process(gobj(), context, output_pad.c_str(), const_cast<const GeglRectangle*>(result_rect.gobj()));
}

void Operation::create_pad(GParamSpec * param_spec)
{
gegl_operation_create_pad(gobj(), param_spec); 
}

void Operation::set_format(const Glib::ustring & pad_name, const Babl * format)
{
gegl_operation_set_format(gobj(), pad_name.c_str(), format); 
}

const Babl* Operation::get_format(const Glib::ustring & pad_name)
{
  return gegl_operation_get_format(gobj(), pad_name.c_str());
}

Glib::RefPtr<Node> Operation::get_source_node(const Glib::ustring & pad_name)
{

  Glib::RefPtr<Node> retvalue = Glib::wrap(gegl_operation_get_source_node(gobj(), pad_name.c_str()));
  if(retvalue)
    retvalue->reference(); //The function does not do a ref for us.
  return retvalue;

}

Glib::RefPtr<const Node> Operation::get_source_node(const Glib::ustring & pad_name) const
{
  return const_cast<Operation*>(this)->get_source_node(pad_name);
}


} // namespace Gegl


namespace Glib
{

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

} /* namespace Glib */


namespace Gegl
{


/* The *_Class implementation: */

const Glib::Class& OperationSource_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_ = &OperationSource_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(gegl_operation_source_get_type());

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

  }

  return *this;
}


void OperationSource_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* OperationSource_Class::wrap_new(GObject* object)
{
  return new OperationSource((GeglOperationSource*)object);
}


/* The implementation: */

GeglOperationSource* OperationSource::gobj_copy()
{
  reference();
  return gobj();
}

OperationSource::OperationSource(const Glib::ConstructParams& construct_params)
:
  Operation(construct_params)
{

}

OperationSource::OperationSource(GeglOperationSource* castitem)
:
  Operation((GeglOperation*)(castitem))
{}


OperationSource::~OperationSource()
{}


OperationSource::CppClassType OperationSource::operationsource_class_; // initialize static member

GType OperationSource::get_type()
{
  return operationsource_class_.init().get_type();
}


GType OperationSource::get_base_type()
{
  return gegl_operation_source_get_type();
}


} // namespace Gegl


namespace Glib
{

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

} /* namespace Glib */


namespace Gegl
{


/* The *_Class implementation: */

const Glib::Class& OperationSink_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_ = &OperationSink_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(gegl_operation_sink_get_type());

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

  }

  return *this;
}


void OperationSink_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* OperationSink_Class::wrap_new(GObject* object)
{
  return new OperationSink((GeglOperationSink*)object);
}


/* The implementation: */

GeglOperationSink* OperationSink::gobj_copy()
{
  reference();
  return gobj();
}

OperationSink::OperationSink(const Glib::ConstructParams& construct_params)
:
  Operation(construct_params)
{

}

OperationSink::OperationSink(GeglOperationSink* castitem)
:
  Operation((GeglOperation*)(castitem))
{}


OperationSink::~OperationSink()
{}


OperationSink::CppClassType OperationSink::operationsink_class_; // initialize static member

GType OperationSink::get_type()
{
  return operationsink_class_.init().get_type();
}


GType OperationSink::get_base_type()
{
  return gegl_operation_sink_get_type();
}


} // namespace Gegl


namespace Glib
{

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

} /* namespace Glib */


namespace Gegl
{


/* The *_Class implementation: */

const Glib::Class& OperationFilter_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_ = &OperationFilter_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(gegl_operation_filter_get_type());

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

  }

  return *this;
}


void OperationFilter_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* OperationFilter_Class::wrap_new(GObject* object)
{
  return new OperationFilter((GeglOperationFilter*)object);
}


/* The implementation: */

GeglOperationFilter* OperationFilter::gobj_copy()
{
  reference();
  return gobj();
}

OperationFilter::OperationFilter(const Glib::ConstructParams& construct_params)
:
  Operation(construct_params)
{

}

OperationFilter::OperationFilter(GeglOperationFilter* castitem)
:
  Operation((GeglOperation*)(castitem))
{}


OperationFilter::~OperationFilter()
{}


OperationFilter::CppClassType OperationFilter::operationfilter_class_; // initialize static member

GType OperationFilter::get_type()
{
  return operationfilter_class_.init().get_type();
}


GType OperationFilter::get_base_type()
{
  return gegl_operation_filter_get_type();
}


} // namespace Gegl


namespace Glib
{

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

} /* namespace Glib */


namespace Gegl
{


/* The *_Class implementation: */

const Glib::Class& OperationComposer_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_ = &OperationComposer_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(gegl_operation_composer_get_type());

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

  }

  return *this;
}


void OperationComposer_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* OperationComposer_Class::wrap_new(GObject* object)
{
  return new OperationComposer((GeglOperationComposer*)object);
}


/* The implementation: */

GeglOperationComposer* OperationComposer::gobj_copy()
{
  reference();
  return gobj();
}

OperationComposer::OperationComposer(const Glib::ConstructParams& construct_params)
:
  Operation(construct_params)
{

}

OperationComposer::OperationComposer(GeglOperationComposer* castitem)
:
  Operation((GeglOperation*)(castitem))
{}


OperationComposer::~OperationComposer()
{}


OperationComposer::CppClassType OperationComposer::operationcomposer_class_; // initialize static member

GType OperationComposer::get_type()
{
  return operationcomposer_class_.init().get_type();
}


GType OperationComposer::get_base_type()
{
  return gegl_operation_composer_get_type();
}


} // namespace Gegl


namespace Glib
{

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

} /* namespace Glib */


namespace Gegl
{


/* The *_Class implementation: */

const Glib::Class& OperationPointComposer_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_ = &OperationPointComposer_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(gegl_operation_point_composer_get_type());

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

  }

  return *this;
}


void OperationPointComposer_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* OperationPointComposer_Class::wrap_new(GObject* object)
{
  return new OperationPointComposer((GeglOperationPointComposer*)object);
}


/* The implementation: */

GeglOperationPointComposer* OperationPointComposer::gobj_copy()
{
  reference();
  return gobj();
}

OperationPointComposer::OperationPointComposer(const Glib::ConstructParams& construct_params)
:
  OperationComposer(construct_params)
{

}

OperationPointComposer::OperationPointComposer(GeglOperationPointComposer* castitem)
:
  OperationComposer((GeglOperationComposer*)(castitem))
{}


OperationPointComposer::~OperationPointComposer()
{}


OperationPointComposer::CppClassType OperationPointComposer::operationpointcomposer_class_; // initialize static member

GType OperationPointComposer::get_type()
{
  return operationpointcomposer_class_.init().get_type();
}


GType OperationPointComposer::get_base_type()
{
  return gegl_operation_point_composer_get_type();
}


} // namespace Gegl


namespace Glib
{

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

} /* namespace Glib */


namespace Gegl
{


/* The *_Class implementation: */

const Glib::Class& OperationPointFilter_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_ = &OperationPointFilter_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(gegl_operation_point_filter_get_type());

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

  }

  return *this;
}


void OperationPointFilter_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* OperationPointFilter_Class::wrap_new(GObject* object)
{
  return new OperationPointFilter((GeglOperationPointFilter*)object);
}


/* The implementation: */

GeglOperationPointFilter* OperationPointFilter::gobj_copy()
{
  reference();
  return gobj();
}

OperationPointFilter::OperationPointFilter(const Glib::ConstructParams& construct_params)
:
  OperationFilter(construct_params)
{

}

OperationPointFilter::OperationPointFilter(GeglOperationPointFilter* castitem)
:
  OperationFilter((GeglOperationFilter*)(castitem))
{}


OperationPointFilter::~OperationPointFilter()
{}


OperationPointFilter::CppClassType OperationPointFilter::operationpointfilter_class_; // initialize static member

GType OperationPointFilter::get_type()
{
  return operationpointfilter_class_.init().get_type();
}


GType OperationPointFilter::get_base_type()
{
  return gegl_operation_point_filter_get_type();
}


} // namespace Gegl


namespace Glib
{

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

} /* namespace Glib */


namespace Gegl
{


/* The *_Class implementation: */

const Glib::Class& OperationAreaFilter_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_ = &OperationAreaFilter_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(gegl_operation_area_filter_get_type());

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

  }

  return *this;
}


void OperationAreaFilter_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* OperationAreaFilter_Class::wrap_new(GObject* object)
{
  return new OperationAreaFilter((GeglOperationAreaFilter*)object);
}


/* The implementation: */

GeglOperationAreaFilter* OperationAreaFilter::gobj_copy()
{
  reference();
  return gobj();
}

OperationAreaFilter::OperationAreaFilter(const Glib::ConstructParams& construct_params)
:
  OperationFilter(construct_params)
{

}

OperationAreaFilter::OperationAreaFilter(GeglOperationAreaFilter* castitem)
:
  OperationFilter((GeglOperationFilter*)(castitem))
{}


OperationAreaFilter::~OperationAreaFilter()
{}


OperationAreaFilter::CppClassType OperationAreaFilter::operationareafilter_class_; // initialize static member

GType OperationAreaFilter::get_type()
{
  return operationareafilter_class_.init().get_type();
}


GType OperationAreaFilter::get_base_type()
{
  return gegl_operation_area_filter_get_type();
}


} // namespace Gegl


namespace Glib
{

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

} /* namespace Glib */


namespace Gegl
{


/* The *_Class implementation: */

const Glib::Class& OperationMeta_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_ = &OperationMeta_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(gegl_operation_meta_get_type());

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

  }

  return *this;
}


void OperationMeta_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* OperationMeta_Class::wrap_new(GObject* object)
{
  return new OperationMeta((GeglOperationMeta*)object);
}


/* The implementation: */

GeglOperationMeta* OperationMeta::gobj_copy()
{
  reference();
  return gobj();
}

OperationMeta::OperationMeta(const Glib::ConstructParams& construct_params)
:
  Operation(construct_params)
{

}

OperationMeta::OperationMeta(GeglOperationMeta* castitem)
:
  Operation((GeglOperation*)(castitem))
{}


OperationMeta::~OperationMeta()
{}


OperationMeta::CppClassType OperationMeta::operationmeta_class_; // initialize static member

GType OperationMeta::get_type()
{
  return operationmeta_class_.init().get_type();
}


GType OperationMeta::get_base_type()
{
  return gegl_operation_meta_get_type();
}

void OperationMeta::property_changed(GParamSpec * arg1, void * user_data)
{
gegl_operation_meta_property_changed(gobj(), arg1, user_data); 
}


} // namespace Gegl


