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


#include <glibmm.h>

/* Copyright (C) 2007 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 <cluttermm/actor.h>
#include <cluttermm/types.h>


#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _ClutterTexture ClutterTexture;
typedef struct _ClutterTextureClass ClutterTextureClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Clutter
{ class Texture_Class; } // namespace Clutter
namespace Clutter
{

/** @addtogroup cluttermmEnums cluttermm Enums and Flags */

/**
 * @ingroup cluttermmEnums
 * @par Bitwise operators:
 * <tt>%TextureFlags operator|(TextureFlags, TextureFlags)</tt><br>
 * <tt>%TextureFlags operator&(TextureFlags, TextureFlags)</tt><br>
 * <tt>%TextureFlags operator^(TextureFlags, TextureFlags)</tt><br>
 * <tt>%TextureFlags operator~(TextureFlags)</tt><br>
 * <tt>%TextureFlags& operator|=(TextureFlags&, TextureFlags)</tt><br>
 * <tt>%TextureFlags& operator&=(TextureFlags&, TextureFlags)</tt><br>
 * <tt>%TextureFlags& operator^=(TextureFlags&, TextureFlags)</tt><br>
 */
enum TextureFlags
{
  TEXTURE_NONE = 0x0,
  TEXTURE_RGB_FLAG_BGR = 1 << 1,
  TEXTURE_RGB_FLAG_PREMULT = 1 << 2,
  TEXTURE_YUV_FLAG_YUV2 = 1 << 3
};

/** @ingroup cluttermmEnums */
inline TextureFlags operator|(TextureFlags lhs, TextureFlags rhs)
  { return static_cast<TextureFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }

/** @ingroup cluttermmEnums */
inline TextureFlags operator&(TextureFlags lhs, TextureFlags rhs)
  { return static_cast<TextureFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }

/** @ingroup cluttermmEnums */
inline TextureFlags operator^(TextureFlags lhs, TextureFlags rhs)
  { return static_cast<TextureFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }

/** @ingroup cluttermmEnums */
inline TextureFlags operator~(TextureFlags flags)
  { return static_cast<TextureFlags>(~static_cast<unsigned>(flags)); }

/** @ingroup cluttermmEnums */
inline TextureFlags& operator|=(TextureFlags& lhs, TextureFlags rhs)
  { return (lhs = static_cast<TextureFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }

/** @ingroup cluttermmEnums */
inline TextureFlags& operator&=(TextureFlags& lhs, TextureFlags rhs)
  { return (lhs = static_cast<TextureFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }

/** @ingroup cluttermmEnums */
inline TextureFlags& operator^=(TextureFlags& lhs, TextureFlags rhs)
  { return (lhs = static_cast<TextureFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }

} // namespace Clutter


#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{

template <>
class Value<Clutter::TextureFlags> : public Glib::Value_Flags<Clutter::TextureFlags>
{
public:
  static GType value_type() G_GNUC_CONST;
};

} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Clutter
{

/**
 * @ingroup cluttermmEnums
 */
enum TextureQuality
{
  TEXTURE_QUALITY_LOW,
  TEXTURE_QUALITY_MEDIUM,
  TEXTURE_QUALITY_HIGH
};

} // namespace Clutter


#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{

template <>
class Value<Clutter::TextureQuality> : public Glib::Value_Enum<Clutter::TextureQuality>
{
public:
  static GType value_type() G_GNUC_CONST;
};

} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Clutter
{


/** Exception class for Clutter::Texture errors.
 */
class TextureError : public Glib::Error
{
public:
  enum Code
  {
    OUT_OF_MEMORY,
    NO_YUV,
    BAD_FORMAT
  };

  TextureError(Code error_code, const Glib::ustring& error_message);
  explicit TextureError(GError* gobject);
  Code code() const;

#ifndef DOXYGEN_SHOULD_SKIP_THIS
private:

  static void throw_func(GError* gobject);

  friend void wrap_init(); // uses throw_func()

  #endif //DOXYGEN_SHOULD_SKIP_THIS
};

} // namespace Clutter

#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{

template <>
class Value<Clutter::TextureError::Code> : public Glib::Value_Enum<Clutter::TextureError::Code>
{
public:
  static GType value_type() G_GNUC_CONST;
};

} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Clutter
{


class Texture : public Actor
{
  
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  typedef Texture CppObjectType;
  typedef Texture_Class CppClassType;
  typedef ClutterTexture BaseObjectType;
  typedef ClutterTextureClass BaseClassType;

private:  friend class Texture_Class;
  static CppClassType texture_class_;

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

protected:
  explicit Texture(const Glib::ConstructParams& construct_params);
  explicit Texture(ClutterTexture* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:
  virtual ~Texture();

#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.
  ClutterTexture*       gobj()       { return reinterpret_cast<ClutterTexture*>(gobject_); }

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

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

private:


protected:
  Texture();
  // We do not wrap this constructor because it might throw an error. This
  // gets difficult to get right especially for disabled exceptions in glibmm,
  // and it is easy enough to create a texture and call set_from_file() on
  // it manually.  But we do wrap the create method at least. --danielk
  

  // TODO: Wrap clutter_texture_new_from_actor. This needs changes in clutter
  // since the _new function does a lot more than calling g_object_new().
  //_WRAP_CTOR(Texture(const Glib::RefPtr<Actor>& actor), clutter_texture_new_from_actor)

public:
 

  static Glib::RefPtr<Texture> create();

  static Glib::RefPtr<Texture> create_from_file(const std::string& filename);
  //_WRAP_CREATE(const Glib::RefPtr<Actor>& actor);

  
  /** Sets the Clutter::Texture image data from an image file. In case of
   * failure, <tt>false</tt> is returned and @a error is set.
   * 
   * If Clutter::Texture:load-async is set to <tt>true</tt>, this function
   * will return as soon as possible, and the actual image loading
   * from disk will be performed asynchronously. Clutter::Texture::size-change
   * will be emitten when the size of the texture is available and
   * Clutter::Texture::load-finished will be emitted when the image has been
   * loaded or if an error occurred.
   * 
   * @newin{0,8}
   * @param filename The filename of the image in GLib file name encoding.
   * @return <tt>true</tt> if the image was successfully loaded and set.
   */
  bool set_from_file(const std::string& filename);
  
  /** Sets Clutter::Texture image data.
   * 
   * @newin{0,4}.
   * @param data Image data in RGBA type colorspace.
   * @param has_alpha Set to <tt>true</tt> if image data has an alpha channel.
   * @param width Width in pixels of image data.
   * @param height Height in pixels of image data.
   * @param rowstride Distance in bytes between row starts.
   * @param bpp Bytes per pixel (Currently only 3 and 4 supported,
   * depending on @a has_alpha).
   * @param flags Clutter::TextureFlags.
   * @return <tt>true</tt> on success, <tt>false</tt> on failure.
   */
  bool set_from_rgb_data(const guchar* data, bool has_alpha, int width, int height, int rowstride, int bpp, TextureFlags flags);
  
  /** Sets a Clutter::Texture from YUV image data. If an error occurred,
   * <tt>false</tt> is returned and @a error is set.
   * 
   * @newin{0,4}
   * @param data Image data in YUV type colorspace.
   * @param width Width in pixels of image data.
   * @param height Height in pixels of image data.
   * @param flags Clutter::TextureFlags.
   * @return <tt>true</tt> if the texture was successfully updated.
   */
  bool set_from_yuv_data(const guchar* data, int width, int height, TextureFlags flags);
  
  /** Updates a sub-region of the pixel data in a Clutter::Texture.
   * 
   * @newin{0,6}
   * @param data Image data in RGB type colorspace.
   * @param has_alpha Set to <tt>true</tt> if image data has an alpha channel.
   * @param x X coordinate of upper left corner of region to update.
   * @param y Y coordinate of upper left corner of region to update.
   * @param width Width in pixels of region to update.
   * @param height Height in pixels of region to update.
   * @param rowstride Distance in bytes between row starts on source buffer.
   * @param bpp Bytes per pixel (Currently only 3 and 4 supported,
   * depending on @a has_alpha).
   * @param flags Clutter::TextureFlags.
   * @return <tt>true</tt> on success, <tt>false</tt> on failure.
   */
  bool set_area_from_rgb_data(const guchar* data, bool has_alpha, int x, int y, int width, int height, int rowstride, int bpp, TextureFlags flags);
  
  /** Gets the size in pixels of the untransformed underlying image
   * @param width Return location for the width, or <tt>0</tt>.
   * @param height Return location for the height, or <tt>0</tt>.
   */
  void get_base_size(int& width, int& height) const;

  
  /** Retrieves the pixel format used by @a texture. This is
   * equivalent to:
   * 
   * |[
   * handle = clutter_texture_get_pixel_format (texture);
   * 
   * if (handle != COGL_INVALID_HANDLE)
   * format = cogl_texture_get_format (handle);
   * ]|
   * 
   * @newin{1,0}
   * @return A Cogl::PixelFormat value.
   */
  CoglPixelFormat get_pixel_format() const;

  
  /** Gets the filter quality used when scaling a texture.
   * 
   * @newin{0,8}
   * @return The filter quality value.
   */
  TextureQuality get_filter_quality() const;
  
  /** Sets the filter quality when scaling a texture. The quality is an
   * enumeration currently the following values are supported:
   * Clutter::TEXTURE_QUALITY_LOW which is fast but only uses nearest neighbour
   * interpolation. Clutter::TEXTURE_QUALITY_MEDIUM which is computationally a
   * bit more expensive (bilinear interpolation), and
   * Clutter::TEXTURE_QUALITY_HIGH which uses extra texture memory resources to
   * improve scaled down rendering as well (by using mipmaps). The default value
   * is Clutter::TEXTURE_QUALITY_MEDIUM.
   * 
   * @newin{0,8}
   * @param filter_quality New filter quality value.
   */
  void set_filter_quality(TextureQuality filter_quality);

  
  /** Gets the maximum waste that will be used when creating a texture or
   * -1 if slicing is disabled.
   * 
   * @newin{0,8}
   * @return The maximum waste or -1 if the texture waste is
   * unlimited.
   */
  int get_max_tile_waste() const;
  //gtkmmproc error: clutter_texture_set_max_tile_waste : method defs lookup failed (1)

  // TODO: Is there a coglmm we could depend on for this?
  
  /** Retrieves the handle to the underlying COGL texture used for drawing
   * the actor. No extra reference is taken so if you need to keep the
   * handle then you should call cogl_handle_ref() on it.
   * 
   * The texture handle returned is the first layer of the material
   * handle used by the Clutter::Texture. If you need to access the other
   * layers you should use get_cogl_material() instead
   * and use the Cogl::Material API.
   * 
   * @newin{0,8}
   * @return COGL texture handle.
   */
  CoglHandle get_cogl_texture() const;
  
  /** Replaces the underlying COGL texture drawn by this actor with
   *  @a cogl_tex. A reference to the texture is taken so if the handle is
   * no longer needed it should be deref'd with cogl_handle_unref.
   * 
   * This should not be called on an unrealizable texture (one that
   * isn't inside a stage). (Currently the ClutterTexture
   * implementation relies on being able to have a GL texture while
   * unrealized, which means you can get away with it, but it's
   * not correct and may change in the future.)
   * 
   * @newin{0,8}
   * @param cogl_tex A CoglHandle for a texture.
   */
  void set_cogl_texture(CoglHandle handle);
  
  /** Returns a handle to the underlying COGL material used for drawing
   * the actor. No extra reference is taken so if you need to keep the
   * handle then you should call cogl_handle_ref() on it.
   * 
   * @newin{1,0}
   * @return COGL material handle.
   */
  CoglHandle get_cogl_material() const;
  
  /** Replaces the underlying Cogl material drawn by this actor with
   *  @a cogl_material. A reference to the material is taken so if the
   * handle is no longer needed it should be deref'd with
   * cogl_handle_unref. Texture data is attached to the material so
   * calling this function also replaces the Cogl
   * texture. Clutter::Texture requires that the material have a texture
   * layer so you should set one on the material before calling this
   * function.
   * 
   * @newin{0,8}
   * @param cogl_material A CoglHandle for a material.
   */
  void set_cogl_material(CoglHandle handle);

  
  /** Retrieves the value set with get_sync_size()
   * 
   * @newin{1,0}
   * @return <tt>true</tt> if the Clutter::Texture should have the same
   * preferred size of the underlying image data.
   */
  bool get_sync_size() const;
  
  /** Sets whether @a texture should have the same preferred size as the
   * underlying image data.
   * 
   * @newin{1,0}
   * @param sync_size <tt>true</tt> if the texture should have the same size of the
   * underlying image data.
   */
  void set_sync_size(bool sync_size=true);

 
  /** Retrieves the horizontal and vertical repeat values set
   * using set_repeat()
   * 
   * @newin{1,0}
   * @param repeat_x Return location for the horizontal repeat.
   * @param repeat_y Return location for the vertical repeat.
   */
  void get_repeat(bool& repeat_x, bool& repeat_y) const;
  
  /** Sets whether the @a texture should repeat horizontally or
   * vertically when the actor size is bigger than the image size
   * 
   * @newin{1,0}
   * @param repeat_x <tt>true</tt> if the texture should repeat horizontally.
   * @param repeat_y <tt>true</tt> if the texture should repeat vertically.
   */
  void set_repeat(bool repeat_x=true, bool repeat_y=true);

  
  /** Retrieves the value set using get_keep_aspect_ratio()
   * 
   * @newin{1,0}
   * @return <tt>true</tt> if the Clutter::Texture should maintain the
   * aspect ratio of the underlying image.
   */
  bool get_keep_aspect_ratio() const;
  
  /** Sets whether @a texture should have a preferred size maintaining
   * the aspect ratio of the underlying image
   * 
   * @newin{1,0}
   * @param keep_aspect <tt>true</tt> to maintain aspect ratio.
   */
  void set_keep_aspect_ratio(bool keep_aspect=true);

  
  /** Retrieves the value set using get_load_async()
   * 
   * @newin{1,0}
   * @return <tt>true</tt> if the Clutter::Texture should load the data from
   * disk asynchronously.
   */
  bool get_load_async() const;
  
  /** Sets whether @a texture should use a worker thread to load the data
   * from disk asynchronously. Setting @a load_async to <tt>true</tt> will make
   * set_from_file() return immediately.
   * 
   * See the Clutter::Texture:load-async property documentation, and
   * set_load_data_async().
   * 
   * @newin{1,0}
   * @param load_async <tt>true</tt> if the texture should asynchronously load data
   * from a filename.
   */
  void set_load_async(bool load_async=true);

  
  /** Retrieves the value set by set_load_data_async()
   * 
   * @newin{1,0}
   * @return <tt>true</tt> if the Clutter::Texture should load the image
   * data from a file asynchronously.
   */
  bool get_load_data_async() const;
  
  /** Sets whether @a texture should use a worker thread to load the data
   * from disk asynchronously. Setting @a load_async to <tt>true</tt> will make
   * set_from_file() block until the Clutter::Texture has
   * determined the width and height of the image data.
   * 
   * See the Clutter::Texture:load-async property documentation, and
   * set_load_async().
   * 
   * @newin{1,0}
   * @param load_async <tt>true</tt> if the texture should asynchronously load data
   * from a filename.
   */
  void set_load_data_async(bool load_async=true);

  
  void set_pick_with_alpha(bool pick_with_alpha = true);
  
  bool get_pick_with_alpha() const;

  // TODO: figure out what to do with this GError parameter
  //_WRAP_SIGNAL(void load_finished(GError* error), "load_finished")
  
  /**
   * @par Prototype:
   * <tt>void on_my_%size_change(int width, int height)</tt>
   */

  Glib::SignalProxy2< void,int,int > signal_size_change();

  
  /**
   * @par Prototype:
   * <tt>void on_my_%pixbuf_change()</tt>
   */

  Glib::SignalProxy0< void > signal_pixbuf_change();


 // TODO: What's with the C type?
  #ifdef GLIBMM_PROPERTIES_ENABLED
/** The underlying COGL texture handle used to draw this actor.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy<CoglHandle> property_cogl_texture() ;
#endif //#GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
/** The underlying COGL texture handle used to draw this actor.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly<CoglHandle> property_cogl_texture() const;
#endif //#GLIBMM_PROPERTIES_ENABLED

  #ifdef GLIBMM_PROPERTIES_ENABLED
/** Force the underlying texture to be singlularand not made of of smaller space saving inidivual textures.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly<bool> property_disable_slicing() const;
#endif //#GLIBMM_PROPERTIES_ENABLED


  #ifdef GLIBMM_PROPERTIES_ENABLED
/** The full path of the file containing the texture.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy_WriteOnly<std::string> property_filename() ;
#endif //#GLIBMM_PROPERTIES_ENABLED


  #ifdef GLIBMM_PROPERTIES_ENABLED
/** Rendering quality used when drawing the texture.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy<TextureQuality> property_filter_quality() ;
#endif //#GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
/** Rendering quality used when drawing the texture.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly<TextureQuality> property_filter_quality() const;
#endif //#GLIBMM_PROPERTIES_ENABLED

  #ifdef GLIBMM_PROPERTIES_ENABLED
/** Keep the aspect ratio of the texture when requesting the preferred width or height.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy<bool> property_keep_aspect_ratio() ;
#endif //#GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
/** Keep the aspect ratio of the texture when requesting the preferred width or height.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly<bool> property_keep_aspect_ratio() const;
#endif //#GLIBMM_PROPERTIES_ENABLED

  #ifdef GLIBMM_PROPERTIES_ENABLED
/** Load files inside a thread to avoid blocking when loading images.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy_WriteOnly<bool> property_load_async() ;
#endif //#GLIBMM_PROPERTIES_ENABLED


  #ifdef GLIBMM_PROPERTIES_ENABLED
/** Decode image data files inside a thread to reduce blocking when loading images.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy_WriteOnly<bool> property_load_data_async() ;
#endif //#GLIBMM_PROPERTIES_ENABLED


  #ifdef GLIBMM_PROPERTIES_ENABLED
/** CoglPixelFormat to use.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly<int> property_pixel_format() const;
#endif //#GLIBMM_PROPERTIES_ENABLED


  #ifdef GLIBMM_PROPERTIES_ENABLED
/** Repeat underlying pixbuf rather than scale in x direction.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy<bool> property_repeat_x() ;
#endif //#GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
/** Repeat underlying pixbuf rather than scale in x direction.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly<bool> property_repeat_x() const;
#endif //#GLIBMM_PROPERTIES_ENABLED

  #ifdef GLIBMM_PROPERTIES_ENABLED
/** Repeat underlying pixbuf rather than scale in y direction.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy<bool> property_repeat_y() ;
#endif //#GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
/** Repeat underlying pixbuf rather than scale in y direction.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly<bool> property_repeat_y() const;
#endif //#GLIBMM_PROPERTIES_ENABLED

  #ifdef GLIBMM_PROPERTIES_ENABLED
/** Auto sync size of actor to underlying pixbuf dimensions.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy<bool> property_sync_size() ;
#endif //#GLIBMM_PROPERTIES_ENABLED

#ifdef GLIBMM_PROPERTIES_ENABLED
/** Auto sync size of actor to underlying pixbuf dimensions.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly<bool> property_sync_size() const;
#endif //#GLIBMM_PROPERTIES_ENABLED

  #ifdef GLIBMM_PROPERTIES_ENABLED
/** Maximum waste area of a sliced texture.
   *
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
   * the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly<int> property_tile_waste() const;
#endif //#GLIBMM_PROPERTIES_ENABLED


public:

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

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

  //Default Signal Handlers::
  virtual void on_size_change(int width, int height);
  virtual void on_pixbuf_change();


};

} // namespace Clutter


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 Clutter::Texture
   */
  Glib::RefPtr<Clutter::Texture> wrap(ClutterTexture* object, bool take_copy = false);
}


#endif /* _CLUTTERMM_TEXTURE_H */

