clutter 2.0.0-x86-mingw32

data/vendor/local/include/clutter-1.0/clutter/clutter-stage-manager.h

@@ -0,0 +1,81 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright (C) 2008 OpenedHand
+ *
+ * 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 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Emmanuele Bassi <ebassi@linux.intel.com>
+ */
+
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be included directly."
+#endif
+
+#ifndef __CLUTTER_STAGE_MANAGER_H__
+#define __CLUTTER_STAGE_MANAGER_H__
+
+#include <clutter/clutter-types.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_TYPE_STAGE_MANAGER              (clutter_stage_manager_get_type ())
+#define CLUTTER_STAGE_MANAGER(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_STAGE_MANAGER, ClutterStageManager))
+#define CLUTTER_IS_STAGE_MANAGER(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_STAGE_MANAGER))
+#define CLUTTER_STAGE_MANAGER_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_STAGE_MANAGER, ClutterStageManagerClass))
+#define CLUTTER_IS_STAGE_MANAGER_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_STAGE_MANAGER))
+#define CLUTTER_STAGE_MANAGER_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_STAGE_MANAGER, ClutterStageManagerClass))
+
+typedef struct _ClutterStageManager             ClutterStageManager;
+typedef struct _ClutterStageManagerClass        ClutterStageManagerClass;
+
+/**
+ * ClutterStageManager:
+ *
+ * The #ClutterStageManager structure is private.
+ *
+ * Since: 1.0
+ */
+
+/**
+ * ClutterStageManagerClass:
+ *
+ * The #ClutterStageManagerClass structure contains only private data
+ * and should be accessed using the provided API
+ *
+ * Since: 1.0
+ */
+struct _ClutterStageManagerClass
+{
+  /*< private >*/
+  GObjectClass parent_class;
+
+  void (* stage_added)   (ClutterStageManager *stage_manager,
+                          ClutterStage        *stage);
+  void (* stage_removed) (ClutterStageManager *stage_manager,
+                          ClutterStage        *stage);
+};
+
+GType clutter_stage_manager_get_type (void) G_GNUC_CONST;
+
+ClutterStageManager *clutter_stage_manager_get_default       (void);
+ClutterStage *       clutter_stage_manager_get_default_stage (ClutterStageManager *stage_manager);
+GSList *             clutter_stage_manager_list_stages       (ClutterStageManager *stage_manager);
+const GSList *       clutter_stage_manager_peek_stages       (ClutterStageManager *stage_manager);
+
+G_END_DECLS
+
+#endif /* __CLUTTER_STAGE_MANAGER_H__ */

data/vendor/local/include/clutter-1.0/clutter/clutter-stage.h

@@ -0,0 +1,215 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By Matthew Allum  <mallum@openedhand.com>
+ *
+ * Copyright (C) 2006 OpenedHand
+ *
+ * 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 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be included directly."
+#endif
+
+#ifndef __CLUTTER_STAGE_H__
+#define __CLUTTER_STAGE_H__
+
+#include <clutter/clutter-types.h>
+#include <clutter/clutter-group.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_TYPE_STAGE              (clutter_stage_get_type())
+
+#define CLUTTER_STAGE(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_STAGE, ClutterStage))
+#define CLUTTER_STAGE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_STAGE, ClutterStageClass))
+#define CLUTTER_IS_STAGE(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_STAGE))
+#define CLUTTER_IS_STAGE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_STAGE))
+#define CLUTTER_STAGE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_STAGE, ClutterStageClass))
+
+typedef struct _ClutterStageClass   ClutterStageClass;
+typedef struct _ClutterStagePrivate ClutterStagePrivate;
+
+/**
+ * ClutterStage:
+ *
+ * The #ClutterStage structure contains only private data
+ * and should be accessed using the provided API
+ *
+ * Since: 0.1
+ */
+struct _ClutterStage
+{
+  /*< private >*/
+  ClutterGroup parent_instance;
+
+  ClutterStagePrivate *priv;
+};
+/**
+ * ClutterStageClass:
+ * @fullscreen: handler for the #ClutterStage::fullscreen signal
+ * @unfullscreen: handler for the #ClutterStage::unfullscreen signal
+ * @activate: handler for the #ClutterStage::activate signal
+ * @deactivate: handler for the #ClutterStage::deactivate signal
+ * @delete_event: handler for the #ClutterStage::delete-event signal
+ *
+ * The #ClutterStageClass structure contains only private data
+ *
+ * Since: 0.1
+ */
+
+struct _ClutterStageClass
+{
+  /*< private >*/
+  ClutterGroupClass parent_class;
+
+  /*< public >*/
+  /* signals */
+  void (* fullscreen)   (ClutterStage *stage);
+  void (* unfullscreen) (ClutterStage *stage);
+  void (* activate)     (ClutterStage *stage);
+  void (* deactivate)   (ClutterStage *stage);
+
+  gboolean (* delete_event) (ClutterStage *stage,
+                             ClutterEvent *event);
+
+  /*< private >*/
+  /* padding for future expansion */
+  gpointer _padding_dummy[31];
+};
+
+/**
+ * ClutterPerspective:
+ * @fovy: the field of view angle, in degrees, in the y direction
+ * @aspect: the aspect ratio that determines the field of view in the x
+ *   direction. The aspect ratio is the ratio of x (width) to y (height)
+ * @z_near: the distance from the viewer to the near clipping
+ *   plane (always positive)
+ * @z_far: the distance from the viewer to the far clipping
+ *   plane (always positive)
+ *
+ * Stage perspective definition. #ClutterPerspective is only used by
+ * the fixed point version of clutter_stage_set_perspective().
+ *
+ * Since: 0.4
+ */
+struct _ClutterPerspective
+{
+  gfloat fovy;
+  gfloat aspect;
+  gfloat z_near;
+  gfloat z_far;
+};
+
+/**
+ * ClutterFog:
+ * @z_near: starting distance from the viewer to the near clipping
+ *   plane (always positive)
+ * @z_far: final distance from the viewer to the far clipping
+ *   plane (always positive)
+ *
+ * Fog settings used to create the depth cueing effect.
+ *
+ * Since: 0.6
+ *
+ * Deprecated: 1.10: The fog-related API in #ClutterStage has been
+ *   deprecated as well.
+ */
+struct _ClutterFog
+{
+  gfloat z_near;
+  gfloat z_far;
+};
+
+GType clutter_perspective_get_type (void) G_GNUC_CONST;
+GType clutter_fog_get_type (void) G_GNUC_CONST;
+GType clutter_stage_get_type (void) G_GNUC_CONST;
+
+ClutterActor *  clutter_stage_new                               (void);
+
+void            clutter_stage_set_perspective                   (ClutterStage          *stage,
+			                                         ClutterPerspective    *perspective);
+void            clutter_stage_get_perspective                   (ClutterStage          *stage,
+			                                         ClutterPerspective    *perspective);
+void            clutter_stage_set_fullscreen                    (ClutterStage          *stage,
+                                                                 gboolean               fullscreen);
+gboolean        clutter_stage_get_fullscreen                    (ClutterStage          *stage);
+void            clutter_stage_show_cursor                       (ClutterStage          *stage);
+void            clutter_stage_hide_cursor                       (ClutterStage          *stage);
+void            clutter_stage_set_title                         (ClutterStage          *stage,
+                                                                 const gchar           *title);
+const gchar *   clutter_stage_get_title                         (ClutterStage          *stage);
+void            clutter_stage_set_user_resizable                (ClutterStage          *stage,
+						                 gboolean               resizable);
+gboolean        clutter_stage_get_user_resizable                (ClutterStage          *stage);
+
+void            clutter_stage_set_minimum_size                  (ClutterStage          *stage,
+                                                                 guint                  width,
+                                                                 guint                  height);
+void            clutter_stage_get_minimum_size                  (ClutterStage          *stage,
+                                                                 guint                 *width,
+                                                                 guint                 *height);
+void            clutter_stage_set_no_clear_hint                 (ClutterStage          *stage,
+                                                                 gboolean               no_clear);
+gboolean        clutter_stage_get_no_clear_hint                 (ClutterStage          *stage);
+void            clutter_stage_set_use_alpha                     (ClutterStage          *stage,
+                                                                 gboolean               use_alpha);
+gboolean        clutter_stage_get_use_alpha                     (ClutterStage          *stage);
+
+void            clutter_stage_set_key_focus                     (ClutterStage          *stage,
+                                                                 ClutterActor          *actor);
+ClutterActor *  clutter_stage_get_key_focus                     (ClutterStage          *stage);
+void            clutter_stage_set_throttle_motion_events        (ClutterStage          *stage,
+                                                                 gboolean               throttle);
+gboolean        clutter_stage_get_throttle_motion_events        (ClutterStage          *stage);
+void            clutter_stage_set_motion_events_enabled         (ClutterStage          *stage,
+                                                                 gboolean               enabled);
+gboolean        clutter_stage_get_motion_events_enabled         (ClutterStage          *stage);
+void            clutter_stage_set_accept_focus                  (ClutterStage          *stage,
+                                                                 gboolean               accept_focus);
+gboolean        clutter_stage_get_accept_focus                  (ClutterStage          *stage);
+gboolean        clutter_stage_event                             (ClutterStage          *stage,
+                                                                 ClutterEvent          *event);
+
+ClutterActor *  clutter_stage_get_actor_at_pos                  (ClutterStage          *stage,
+                                                                 ClutterPickMode        pick_mode,
+                                                                 gint                   x,
+                                                                 gint                   y);
+guchar *        clutter_stage_read_pixels                       (ClutterStage          *stage,
+                                                                 gint                   x,
+                                                                 gint                   y,
+                                                                 gint                   width,
+                                                                 gint                   height);
+
+void            clutter_stage_get_redraw_clip_bounds            (ClutterStage          *stage,
+                                                                 cairo_rectangle_int_t *clip);
+
+void            clutter_stage_ensure_current                    (ClutterStage          *stage);
+void            clutter_stage_ensure_viewport                   (ClutterStage          *stage);
+void            clutter_stage_ensure_redraw                     (ClutterStage          *stage);
+
+#ifdef CLUTTER_ENABLE_EXPERIMENTAL_API
+CLUTTER_AVAILABLE_IN_1_14
+void            clutter_stage_set_sync_delay                    (ClutterStage          *stage,
+                                                                 gint                   sync_delay);
+CLUTTER_AVAILABLE_IN_1_14
+void            clutter_stage_skip_sync_delay                   (ClutterStage          *stage);
+#endif
+
+G_END_DECLS
+
+#endif /* __CLUTTER_STAGE_H__ */

data/vendor/local/include/clutter-1.0/clutter/clutter-swipe-action.h

@@ -0,0 +1,107 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright (C) 2010  Intel Corporation.
+ * Copyright (C) 2011  Robert Bosch Car Multimedia GmbH.
+ *
+ * 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 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author:
+ *   Tomeu Vizoso <tomeu.vizoso@collabora.co.uk>
+ *
+ * Based on ClutterDragAction, written by:
+ *   Emmanuele Bassi <ebassi@linux.intel.com>
+ */
+
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be included directly."
+#endif
+
+#ifndef __CLUTTER_SWIPE_ACTION_H__
+#define __CLUTTER_SWIPE_ACTION_H__
+
+#include <clutter/clutter-gesture-action.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_TYPE_SWIPE_ACTION               (clutter_swipe_action_get_type ())
+#define CLUTTER_SWIPE_ACTION(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_SWIPE_ACTION, ClutterSwipeAction))
+#define CLUTTER_IS_SWIPE_ACTION(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_SWIPE_ACTION))
+#define CLUTTER_SWIPE_ACTION_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_SWIPE_ACTION, ClutterSwipeActionClass))
+#define CLUTTER_IS_SWIPE_ACTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_SWIPE_ACTION))
+#define CLUTTER_SWIPE_ACTION_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_SWIPE_ACTION, ClutterSwipeActionClass))
+
+typedef struct _ClutterSwipeAction              ClutterSwipeAction;
+typedef struct _ClutterSwipeActionPrivate       ClutterSwipeActionPrivate;
+typedef struct _ClutterSwipeActionClass         ClutterSwipeActionClass;
+
+/**
+ * ClutterSwipeAction:
+ *
+ * The <structname>ClutterSwipeAction</structname> structure contains
+ * only private data and should be accessed using the provided API
+ *
+ * Since: 1.8
+ */
+struct _ClutterSwipeAction
+{
+  /*< private >*/
+  ClutterGestureAction parent_instance;
+
+  ClutterSwipeActionPrivate *priv;
+};
+
+/**
+ * ClutterSwipeActionClass:
+ * @swept: class handler for the #ClutterSwipeAction::swept signal;
+ *   deprecated since 1.14
+ * @swipe: class handler for the #ClutterSwipeAction::swipe signal
+ *
+ * The <structname>ClutterSwipeActionClass</structname> structure contains
+ * only private data.
+ *
+ * Since: 1.8
+ */
+struct _ClutterSwipeActionClass
+{
+  /*< private >*/
+  ClutterGestureActionClass parent_class;
+
+  /*< public >*/
+  void (* swept)  (ClutterSwipeAction    *action,
+                   ClutterActor          *actor,
+                   ClutterSwipeDirection  direction);
+
+  gboolean (* swipe) (ClutterSwipeAction    *action,
+                      ClutterActor          *actor,
+                      ClutterSwipeDirection  direction);
+
+  /*< private >*/
+  void (* _clutter_swipe_action1) (void);
+  void (* _clutter_swipe_action2) (void);
+  void (* _clutter_swipe_action3) (void);
+  void (* _clutter_swipe_action4) (void);
+  void (* _clutter_swipe_action5) (void);
+  void (* _clutter_swipe_action6) (void);
+};
+
+GType clutter_swipe_action_get_type (void) G_GNUC_CONST;
+
+ClutterAction * clutter_swipe_action_new        (void);
+
+G_END_DECLS
+
+#endif /* __CLUTTER_SWIPE_ACTION_H__ */

data/vendor/local/include/clutter-1.0/clutter/clutter-table-layout.h

@@ -0,0 +1,157 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Copyright (C) 2010  Intel Corporation.
+ *
+ * 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 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Author:
+ *   Jose Dapena Paz <jdapena@igalia.com>
+ *
+ * Based on the MX MxTable actor by:
+ *   Thomas Wood <thomas.wood@intel.com>
+ */
+
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be included directly."
+#endif
+
+#ifndef __CLUTTER_TABLE_LAYOUT_H__
+#define __CLUTTER_TABLE_LAYOUT_H__
+
+#include <clutter/clutter-layout-manager.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_TYPE_TABLE_LAYOUT                 (clutter_table_layout_get_type ())
+#define CLUTTER_TABLE_LAYOUT(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_TABLE_LAYOUT, ClutterTableLayout))
+#define CLUTTER_IS_TABLE_LAYOUT(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_TABLE_LAYOUT))
+#define CLUTTER_TABLE_LAYOUT_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_TABLE_LAYOUT, ClutterTableLayoutClass))
+#define CLUTTER_IS_TABLE_LAYOUT_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_TABLE_LAYOUT))
+#define CLUTTER_TABLE_LAYOUT_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_TABLE_LAYOUT, ClutterTableLayoutClass))
+
+typedef struct _ClutterTableLayout                ClutterTableLayout;
+typedef struct _ClutterTableLayoutPrivate         ClutterTableLayoutPrivate;
+typedef struct _ClutterTableLayoutClass           ClutterTableLayoutClass;
+
+/**
+ * ClutterTableLayout:
+ *
+ * The #ClutterTableLayout structure contains only private data
+ * and should be accessed using the provided API
+ *
+ * Since: 1.4
+ */
+struct _ClutterTableLayout
+{
+  /*< private >*/
+  ClutterLayoutManager parent_instance;
+
+  ClutterTableLayoutPrivate *priv;
+};
+
+/**
+ * ClutterTableLayoutClass:
+ *
+ * The #ClutterTableLayoutClass structure contains only private
+ * data and should be accessed using the provided API
+ *
+ * Since: 1.4
+ */
+struct _ClutterTableLayoutClass
+{
+  /*< private >*/
+  ClutterLayoutManagerClass parent_class;
+};
+
+GType clutter_table_layout_get_type (void) G_GNUC_CONST;
+
+ClutterLayoutManager *clutter_table_layout_new                 (void);
+
+void                  clutter_table_layout_pack                (ClutterTableLayout    *layout,
+                                                                ClutterActor          *actor,
+                                                                gint                   column,
+                                                                gint                   row);
+
+void                  clutter_table_layout_set_column_spacing  (ClutterTableLayout    *layout,
+                                                                guint                  spacing);
+void                  clutter_table_layout_set_row_spacing     (ClutterTableLayout    *layout,
+                                                                guint                  spacing);
+guint                 clutter_table_layout_get_column_spacing  (ClutterTableLayout    *layout);
+guint                 clutter_table_layout_get_row_spacing     (ClutterTableLayout    *layout);
+
+void                  clutter_table_layout_set_span            (ClutterTableLayout    *layout,
+                                                                ClutterActor          *actor,
+                                                                gint                   column_span,
+                                                                gint                   row_span);
+void                  clutter_table_layout_get_span            (ClutterTableLayout    *layout,
+                                                                ClutterActor          *actor,
+                                                                gint                  *column_span,
+                                                                gint                  *row_span);
+
+CLUTTER_DEPRECATED_IN_1_12
+void                  clutter_table_layout_set_alignment       (ClutterTableLayout    *layout,
+                                                                ClutterActor          *actor,
+                                                                ClutterTableAlignment  x_align,
+                                                                ClutterTableAlignment  y_align);
+CLUTTER_DEPRECATED_IN_1_12
+void                  clutter_table_layout_get_alignment       (ClutterTableLayout    *layout,
+                                                                ClutterActor          *actor,
+                                                                ClutterTableAlignment *x_align,
+                                                                ClutterTableAlignment *y_align);
+CLUTTER_DEPRECATED_IN_1_12
+void                  clutter_table_layout_set_fill            (ClutterTableLayout    *layout,
+                                                                ClutterActor          *actor,
+                                                                gboolean               x_fill,
+                                                                gboolean               y_fill);
+CLUTTER_DEPRECATED_IN_1_12
+void                  clutter_table_layout_get_fill            (ClutterTableLayout    *layout,
+                                                                ClutterActor          *actor,
+                                                                gboolean              *x_fill,
+                                                                gboolean              *y_fill);
+CLUTTER_DEPRECATED_IN_1_12
+void                  clutter_table_layout_set_expand          (ClutterTableLayout    *layout,
+                                                                ClutterActor          *actor,
+                                                                gboolean               x_expand,
+                                                                gboolean               y_expand);
+CLUTTER_DEPRECATED_IN_1_12
+void                  clutter_table_layout_get_expand          (ClutterTableLayout    *layout,
+                                                                ClutterActor          *actor,
+                                                                gboolean              *x_expand,
+                                                                gboolean              *y_expand);
+
+gint                  clutter_table_layout_get_row_count       (ClutterTableLayout    *layout);
+gint                  clutter_table_layout_get_column_count    (ClutterTableLayout    *layout);
+
+CLUTTER_DEPRECATED_IN_1_12
+void                  clutter_table_layout_set_use_animations  (ClutterTableLayout    *layout,
+                                                                gboolean               animate);
+CLUTTER_DEPRECATED_IN_1_12
+gboolean              clutter_table_layout_get_use_animations  (ClutterTableLayout    *layout);
+CLUTTER_DEPRECATED_IN_1_12
+void                  clutter_table_layout_set_easing_mode     (ClutterTableLayout    *layout,
+                                                                gulong                 mode);
+CLUTTER_DEPRECATED_IN_1_12
+gulong                clutter_table_layout_get_easing_mode     (ClutterTableLayout    *layout);
+CLUTTER_DEPRECATED_IN_1_12
+void                  clutter_table_layout_set_easing_duration (ClutterTableLayout    *layout,
+                                                                guint                  msecs);
+CLUTTER_DEPRECATED_IN_1_12
+guint                 clutter_table_layout_get_easing_duration (ClutterTableLayout    *layout);
+
+G_END_DECLS
+
+#endif /* __CLUTTER_TABLE_LAYOUT_H__ */