// -*- c++ -*-
// Generated by gtkmmproc -- DO NOT MODIFY!
#ifndef _GEGLMM_OPERATION_H
#define _GEGLMM_OPERATION_H


#include <glibmm.h>

/* libgeglmm - a C++ wrapper for libgegl
 *
 * (c) 2008-2009 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 <gegl.h>

#include <geglmm/rectangle.h>


// gegl-plugin seems to include config.h. BAD.
#undef HAVE_CONFIG_H
#include <gegl-plugin.h>

#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GeglOperation GeglOperation;
typedef struct _GeglOperationClass GeglOperationClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gegl
{ class Operation_Class; } // namespace Gegl
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GeglOperationSource GeglOperationSource;
typedef struct _GeglOperationSourceClass GeglOperationSourceClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gegl
{ class OperationSource_Class; } // namespace Gegl
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GeglOperationSink GeglOperationSink;
typedef struct _GeglOperationSinkClass GeglOperationSinkClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gegl
{ class OperationSink_Class; } // namespace Gegl
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GeglOperationFilter GeglOperationFilter;
typedef struct _GeglOperationFilterClass GeglOperationFilterClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gegl
{ class OperationFilter_Class; } // namespace Gegl
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GeglOperationComposer GeglOperationComposer;
typedef struct _GeglOperationComposerClass GeglOperationComposerClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gegl
{ class OperationComposer_Class; } // namespace Gegl
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GeglOperationPointComposer GeglOperationPointComposer;
typedef struct _GeglOperationPointComposerClass GeglOperationPointComposerClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gegl
{ class OperationPointComposer_Class; } // namespace Gegl
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GeglOperationPointFilter GeglOperationPointFilter;
typedef struct _GeglOperationPointFilterClass GeglOperationPointFilterClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gegl
{ class OperationPointFilter_Class; } // namespace Gegl
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GeglOperationAreaFilter GeglOperationAreaFilter;
typedef struct _GeglOperationAreaFilterClass GeglOperationAreaFilterClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gegl
{ class OperationAreaFilter_Class; } // namespace Gegl
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GeglOperationMeta GeglOperationMeta;
typedef struct _GeglOperationMetaClass GeglOperationMetaClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Gegl
{ class OperationMeta_Class; } // namespace Gegl
namespace Gegl {

class Node;
class NodeContext;

//TODO: Document how these should be created (Add create() methods?) or obtained.


class Operation
	: public Glib::Object
{
	
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  typedef Operation CppObjectType;
  typedef Operation_Class CppClassType;
  typedef GeglOperation BaseObjectType;
  typedef GeglOperationClass BaseClassType;

private:  friend class Operation_Class;
  static CppClassType operation_class_;

private:
  // noncopyable
  Operation(const Operation&);
  Operation& operator=(const Operation&);

protected:
  explicit Operation(const Glib::ConstructParams& construct_params);
  explicit Operation(GeglOperation* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:
  virtual ~Operation();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  static GType get_type()      G_GNUC_CONST;


  static GType get_base_type() G_GNUC_CONST;
#endif

  ///Provides access to the underlying C GObject.
  GeglOperation*       gobj()       { return reinterpret_cast<GeglOperation*>(gobject_); }

  ///Provides access to the underlying C GObject.
  const GeglOperation* gobj() const { return reinterpret_cast<GeglOperation*>(gobject_); }

  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
  GeglOperation* gobj_copy();

private:

public:
	
  Rectangle get_invalidated_by_change(const Glib::ustring & input_pad, const Rectangle & input_region) const;
	
  Rectangle get_bounding_box() const;
	
  Rectangle source_get_bounding_box(const Glib::ustring & pad_name) const;
	
  Rectangle get_cached_region(const Rectangle & roi) const;
	
  Rectangle get_required_for_output(const Glib::ustring & input_pda, const Rectangle & roi) const;
	
  Glib::RefPtr<Node> detect(int x, int y);
	
  Glib::RefPtr<const Node> detect(int x, int y) const;
	
  void attach(const Glib::RefPtr<Node> & node);
	
  void prepare();
	
  bool process(GeglOperationContext * context, const Glib::ustring & output_pad, const Rectangle & result_rect);
	
  void create_pad(GParamSpec * param_spec);
	
  void set_format(const Glib::ustring & pad_name, const Babl * format);
	
  const Babl* get_format(const Glib::ustring & pad_name); //TODO: Wrap Babl.
	
  Glib::RefPtr<Node> get_source_node(const Glib::ustring & pad_name);
	
  Glib::RefPtr<const Node> get_source_node(const Glib::ustring & pad_name) const;

	// this one is implemented in OperationMeta
	

public:

public:
  //C++ methods used to invoke GTK+ virtual functions:

protected:
  //GTK+ Virtual Functions (override these to change behaviour):

  //Default Signal Handlers::


};


class OperationSource 
	: public Operation
{
	
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  typedef OperationSource CppObjectType;
  typedef OperationSource_Class CppClassType;
  typedef GeglOperationSource BaseObjectType;
  typedef GeglOperationSourceClass BaseClassType;

private:  friend class OperationSource_Class;
  static CppClassType operationsource_class_;

private:
  // noncopyable
  OperationSource(const OperationSource&);
  OperationSource& operator=(const OperationSource&);

protected:
  explicit OperationSource(const Glib::ConstructParams& construct_params);
  explicit OperationSource(GeglOperationSource* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:
  virtual ~OperationSource();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  static GType get_type()      G_GNUC_CONST;


  static GType get_base_type() G_GNUC_CONST;
#endif

  ///Provides access to the underlying C GObject.
  GeglOperationSource*       gobj()       { return reinterpret_cast<GeglOperationSource*>(gobject_); }

  ///Provides access to the underlying C GObject.
  const GeglOperationSource* gobj() const { return reinterpret_cast<GeglOperationSource*>(gobject_); }

  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
  GeglOperationSource* gobj_copy();

private:


public:

public:
  //C++ methods used to invoke GTK+ virtual functions:

protected:
  //GTK+ Virtual Functions (override these to change behaviour):

  //Default Signal Handlers::


};


class OperationSink 
	: public Operation
{
	
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  typedef OperationSink CppObjectType;
  typedef OperationSink_Class CppClassType;
  typedef GeglOperationSink BaseObjectType;
  typedef GeglOperationSinkClass BaseClassType;

private:  friend class OperationSink_Class;
  static CppClassType operationsink_class_;

private:
  // noncopyable
  OperationSink(const OperationSink&);
  OperationSink& operator=(const OperationSink&);

protected:
  explicit OperationSink(const Glib::ConstructParams& construct_params);
  explicit OperationSink(GeglOperationSink* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:
  virtual ~OperationSink();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  static GType get_type()      G_GNUC_CONST;


  static GType get_base_type() G_GNUC_CONST;
#endif

  ///Provides access to the underlying C GObject.
  GeglOperationSink*       gobj()       { return reinterpret_cast<GeglOperationSink*>(gobject_); }

  ///Provides access to the underlying C GObject.
  const GeglOperationSink* gobj() const { return reinterpret_cast<GeglOperationSink*>(gobject_); }

  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
  GeglOperationSink* gobj_copy();

private:

public:
	//	_WRAP_METHOD(bool needs_full(), gegl_operation_sink_needs_full)


public:

public:
  //C++ methods used to invoke GTK+ virtual functions:

protected:
  //GTK+ Virtual Functions (override these to change behaviour):

  //Default Signal Handlers::


};


class OperationFilter 
	: public Operation
{
	
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  typedef OperationFilter CppObjectType;
  typedef OperationFilter_Class CppClassType;
  typedef GeglOperationFilter BaseObjectType;
  typedef GeglOperationFilterClass BaseClassType;

private:  friend class OperationFilter_Class;
  static CppClassType operationfilter_class_;

private:
  // noncopyable
  OperationFilter(const OperationFilter&);
  OperationFilter& operator=(const OperationFilter&);

protected:
  explicit OperationFilter(const Glib::ConstructParams& construct_params);
  explicit OperationFilter(GeglOperationFilter* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:
  virtual ~OperationFilter();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  static GType get_type()      G_GNUC_CONST;


  static GType get_base_type() G_GNUC_CONST;
#endif

  ///Provides access to the underlying C GObject.
  GeglOperationFilter*       gobj()       { return reinterpret_cast<GeglOperationFilter*>(gobject_); }

  ///Provides access to the underlying C GObject.
  const GeglOperationFilter* gobj() const { return reinterpret_cast<GeglOperationFilter*>(gobject_); }

  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
  GeglOperationFilter* gobj_copy();

private:


public:

public:
  //C++ methods used to invoke GTK+ virtual functions:

protected:
  //GTK+ Virtual Functions (override these to change behaviour):

  //Default Signal Handlers::


};


class OperationComposer 
	: public Operation
{
	
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  typedef OperationComposer CppObjectType;
  typedef OperationComposer_Class CppClassType;
  typedef GeglOperationComposer BaseObjectType;
  typedef GeglOperationComposerClass BaseClassType;

private:  friend class OperationComposer_Class;
  static CppClassType operationcomposer_class_;

private:
  // noncopyable
  OperationComposer(const OperationComposer&);
  OperationComposer& operator=(const OperationComposer&);

protected:
  explicit OperationComposer(const Glib::ConstructParams& construct_params);
  explicit OperationComposer(GeglOperationComposer* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:
  virtual ~OperationComposer();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  static GType get_type()      G_GNUC_CONST;


  static GType get_base_type() G_GNUC_CONST;
#endif

  ///Provides access to the underlying C GObject.
  GeglOperationComposer*       gobj()       { return reinterpret_cast<GeglOperationComposer*>(gobject_); }

  ///Provides access to the underlying C GObject.
  const GeglOperationComposer* gobj() const { return reinterpret_cast<GeglOperationComposer*>(gobject_); }

  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
  GeglOperationComposer* gobj_copy();

private:


public:

public:
  //C++ methods used to invoke GTK+ virtual functions:

protected:
  //GTK+ Virtual Functions (override these to change behaviour):

  //Default Signal Handlers::


};


class OperationPointComposer 
	: public OperationComposer
{
	
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  typedef OperationPointComposer CppObjectType;
  typedef OperationPointComposer_Class CppClassType;
  typedef GeglOperationPointComposer BaseObjectType;
  typedef GeglOperationPointComposerClass BaseClassType;

private:  friend class OperationPointComposer_Class;
  static CppClassType operationpointcomposer_class_;

private:
  // noncopyable
  OperationPointComposer(const OperationPointComposer&);
  OperationPointComposer& operator=(const OperationPointComposer&);

protected:
  explicit OperationPointComposer(const Glib::ConstructParams& construct_params);
  explicit OperationPointComposer(GeglOperationPointComposer* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:
  virtual ~OperationPointComposer();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  static GType get_type()      G_GNUC_CONST;


  static GType get_base_type() G_GNUC_CONST;
#endif

  ///Provides access to the underlying C GObject.
  GeglOperationPointComposer*       gobj()       { return reinterpret_cast<GeglOperationPointComposer*>(gobject_); }

  ///Provides access to the underlying C GObject.
  const GeglOperationPointComposer* gobj() const { return reinterpret_cast<GeglOperationPointComposer*>(gobject_); }

  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
  GeglOperationPointComposer* gobj_copy();

private:


public:

public:
  //C++ methods used to invoke GTK+ virtual functions:

protected:
  //GTK+ Virtual Functions (override these to change behaviour):

  //Default Signal Handlers::


};


class OperationPointFilter 
	: public OperationFilter
{
	
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  typedef OperationPointFilter CppObjectType;
  typedef OperationPointFilter_Class CppClassType;
  typedef GeglOperationPointFilter BaseObjectType;
  typedef GeglOperationPointFilterClass BaseClassType;

private:  friend class OperationPointFilter_Class;
  static CppClassType operationpointfilter_class_;

private:
  // noncopyable
  OperationPointFilter(const OperationPointFilter&);
  OperationPointFilter& operator=(const OperationPointFilter&);

protected:
  explicit OperationPointFilter(const Glib::ConstructParams& construct_params);
  explicit OperationPointFilter(GeglOperationPointFilter* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:
  virtual ~OperationPointFilter();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  static GType get_type()      G_GNUC_CONST;


  static GType get_base_type() G_GNUC_CONST;
#endif

  ///Provides access to the underlying C GObject.
  GeglOperationPointFilter*       gobj()       { return reinterpret_cast<GeglOperationPointFilter*>(gobject_); }

  ///Provides access to the underlying C GObject.
  const GeglOperationPointFilter* gobj() const { return reinterpret_cast<GeglOperationPointFilter*>(gobject_); }

  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
  GeglOperationPointFilter* gobj_copy();

private:


public:

public:
  //C++ methods used to invoke GTK+ virtual functions:

protected:
  //GTK+ Virtual Functions (override these to change behaviour):

  //Default Signal Handlers::


};


class OperationAreaFilter 
	: public OperationFilter
{
	
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  typedef OperationAreaFilter CppObjectType;
  typedef OperationAreaFilter_Class CppClassType;
  typedef GeglOperationAreaFilter BaseObjectType;
  typedef GeglOperationAreaFilterClass BaseClassType;

private:  friend class OperationAreaFilter_Class;
  static CppClassType operationareafilter_class_;

private:
  // noncopyable
  OperationAreaFilter(const OperationAreaFilter&);
  OperationAreaFilter& operator=(const OperationAreaFilter&);

protected:
  explicit OperationAreaFilter(const Glib::ConstructParams& construct_params);
  explicit OperationAreaFilter(GeglOperationAreaFilter* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:
  virtual ~OperationAreaFilter();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  static GType get_type()      G_GNUC_CONST;


  static GType get_base_type() G_GNUC_CONST;
#endif

  ///Provides access to the underlying C GObject.
  GeglOperationAreaFilter*       gobj()       { return reinterpret_cast<GeglOperationAreaFilter*>(gobject_); }

  ///Provides access to the underlying C GObject.
  const GeglOperationAreaFilter* gobj() const { return reinterpret_cast<GeglOperationAreaFilter*>(gobject_); }

  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
  GeglOperationAreaFilter* gobj_copy();

private:


public:

public:
  //C++ methods used to invoke GTK+ virtual functions:

protected:
  //GTK+ Virtual Functions (override these to change behaviour):

  //Default Signal Handlers::


};


class OperationMeta 
	: public Operation
{
	
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  typedef OperationMeta CppObjectType;
  typedef OperationMeta_Class CppClassType;
  typedef GeglOperationMeta BaseObjectType;
  typedef GeglOperationMetaClass BaseClassType;

private:  friend class OperationMeta_Class;
  static CppClassType operationmeta_class_;

private:
  // noncopyable
  OperationMeta(const OperationMeta&);
  OperationMeta& operator=(const OperationMeta&);

protected:
  explicit OperationMeta(const Glib::ConstructParams& construct_params);
  explicit OperationMeta(GeglOperationMeta* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:
  virtual ~OperationMeta();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  static GType get_type()      G_GNUC_CONST;


  static GType get_base_type() G_GNUC_CONST;
#endif

  ///Provides access to the underlying C GObject.
  GeglOperationMeta*       gobj()       { return reinterpret_cast<GeglOperationMeta*>(gobject_); }

  ///Provides access to the underlying C GObject.
  const GeglOperationMeta* gobj() const { return reinterpret_cast<GeglOperationMeta*>(gobject_); }

  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
  GeglOperationMeta* gobj_copy();

private:

public:
	//	_WRAP_METHOD(void redirect(const Glib::ustring & name, const Glib::RefPtr<Node> & internal, const Glib::ustring & internal_name), gegl_operation_meta_redirect)
	
  void property_changed(GParamSpec * arg1, void * user_data);


public:

public:
  //C++ methods used to invoke GTK+ virtual functions:

protected:
  //GTK+ Virtual Functions (override these to change behaviour):

  //Default Signal Handlers::


};


}


namespace Glib
{
  /** A Glib::wrap() method for this object.
   * 
   * @param object The C instance.
   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
   * @result A C++ instance that wraps this C instance.
   *
   * @relates Gegl::Operation
   */
  Glib::RefPtr<Gegl::Operation> wrap(GeglOperation* object, bool take_copy = false);
}


namespace Glib
{
  /** A Glib::wrap() method for this object.
   * 
   * @param object The C instance.
   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
   * @result A C++ instance that wraps this C instance.
   *
   * @relates Gegl::OperationSource
   */
  Glib::RefPtr<Gegl::OperationSource> wrap(GeglOperationSource* object, bool take_copy = false);
}


namespace Glib
{
  /** A Glib::wrap() method for this object.
   * 
   * @param object The C instance.
   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
   * @result A C++ instance that wraps this C instance.
   *
   * @relates Gegl::OperationSink
   */
  Glib::RefPtr<Gegl::OperationSink> wrap(GeglOperationSink* object, bool take_copy = false);
}


namespace Glib
{
  /** A Glib::wrap() method for this object.
   * 
   * @param object The C instance.
   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
   * @result A C++ instance that wraps this C instance.
   *
   * @relates Gegl::OperationFilter
   */
  Glib::RefPtr<Gegl::OperationFilter> wrap(GeglOperationFilter* object, bool take_copy = false);
}


namespace Glib
{
  /** A Glib::wrap() method for this object.
   * 
   * @param object The C instance.
   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
   * @result A C++ instance that wraps this C instance.
   *
   * @relates Gegl::OperationComposer
   */
  Glib::RefPtr<Gegl::OperationComposer> wrap(GeglOperationComposer* object, bool take_copy = false);
}


namespace Glib
{
  /** A Glib::wrap() method for this object.
   * 
   * @param object The C instance.
   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
   * @result A C++ instance that wraps this C instance.
   *
   * @relates Gegl::OperationPointComposer
   */
  Glib::RefPtr<Gegl::OperationPointComposer> wrap(GeglOperationPointComposer* object, bool take_copy = false);
}


namespace Glib
{
  /** A Glib::wrap() method for this object.
   * 
   * @param object The C instance.
   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
   * @result A C++ instance that wraps this C instance.
   *
   * @relates Gegl::OperationPointFilter
   */
  Glib::RefPtr<Gegl::OperationPointFilter> wrap(GeglOperationPointFilter* object, bool take_copy = false);
}


namespace Glib
{
  /** A Glib::wrap() method for this object.
   * 
   * @param object The C instance.
   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
   * @result A C++ instance that wraps this C instance.
   *
   * @relates Gegl::OperationAreaFilter
   */
  Glib::RefPtr<Gegl::OperationAreaFilter> wrap(GeglOperationAreaFilter* object, bool take_copy = false);
}


namespace Glib
{
  /** A Glib::wrap() method for this object.
   * 
   * @param object The C instance.
   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
   * @result A C++ instance that wraps this C instance.
   *
   * @relates Gegl::OperationMeta
   */
  Glib::RefPtr<Gegl::OperationMeta> wrap(GeglOperationMeta* object, bool take_copy = false);
}


#endif /* _GEGLMM_OPERATION_H */

