[clutter/clutter-1.18] Annotate all public symbols



commit c69bb976b3e92cb4d4ef270fb955ce1c8f85a281
Author: Emmanuele Bassi <ebassi gnome org>
Date:   Mon Mar 17 18:19:52 2014 +0000

    Annotate all public symbols
    
    We are going to switch to compiler annotations to determine the
    visibility of the symbols.

 clutter/clutter-action.h                     |   11 +++-
 clutter/clutter-actor-meta.h                 |    6 ++
 clutter/clutter-actor.c                      |    2 -
 clutter/clutter-actor.h                      |   89 ++++++++++++++++++++++++++
 clutter/clutter-align-constraint.h           |    8 ++
 clutter/clutter-animatable.h                 |    5 ++
 clutter/clutter-backend.h                    |   22 ++++--
 clutter/clutter-bin-layout.h                 |    6 +-
 clutter/clutter-bind-constraint.h            |    8 ++
 clutter/clutter-binding-pool.h               |   13 ++++
 clutter/clutter-blur-effect.h                |    2 +
 clutter/clutter-box-layout.h                 |    9 +++
 clutter/clutter-brightness-contrast-effect.h |    8 ++
 clutter/clutter-cairo.h                      |    2 +
 clutter/clutter-child-meta.h                 |    9 ++-
 clutter/clutter-click-action.h               |    6 ++
 clutter/clutter-clone.h                      |   12 ++-
 clutter/clutter-color.h                      |   39 +++++++++--
 clutter/clutter-colorize-effect.h            |    4 +
 clutter/clutter-constraint.h                 |    9 +++
 clutter/clutter-container.h                  |   86 ++++++++++++++-----------
 clutter/clutter-deform-effect.h              |   28 +++++---
 clutter/clutter-desaturate-effect.h          |    4 +
 clutter/clutter-device-manager.h             |    8 ++-
 clutter/clutter-drag-action.h                |   10 +++
 clutter/clutter-drop-action.h                |    2 +
 clutter/clutter-effect.h                     |   12 +++-
 clutter/clutter-enum-types.c.in              |    1 +
 clutter/clutter-enum-types.h.in              |   19 +++--
 clutter/clutter-event.h                      |   52 +++++++++++++--
 clutter/clutter-feature.h                    |    2 +
 clutter/clutter-fixed-layout.h               |    2 +
 clutter/clutter-flow-layout.h                |   14 ++++
 clutter/clutter-gesture-action.h             |    7 ++
 clutter/clutter-group.h                      |    1 +
 clutter/clutter-input-device.h               |   20 ++++++
 clutter/clutter-interval.c                   |    8 ++-
 clutter/clutter-interval.h                   |   18 +++++
 clutter/clutter-layout-manager.h             |   13 ++++
 clutter/clutter-layout-meta.h                |    2 +
 clutter/clutter-list-model.h                 |    3 +
 clutter/clutter-macros.h                     |   78 ++++++++++++----------
 clutter/clutter-main.h                       |   36 ++++++++++
 clutter/clutter-model.h                      |   43 ++++++++++++-
 clutter/clutter-offscreen-effect.h           |    4 +
 clutter/clutter-page-turn-effect.h           |    8 ++
 clutter/clutter-path-constraint.h            |    6 ++
 clutter/clutter-path.h                       |   26 ++++++++
 clutter/clutter-script.h                     |   16 +++++
 clutter/clutter-scriptable.h                 |    5 ++
 clutter/clutter-settings.h                   |    2 +
 clutter/clutter-shader-effect.h              |    7 ++
 clutter/clutter-shader-types.h               |   11 +++-
 clutter/clutter-snap-constraint.h            |    8 ++
 clutter/clutter-stage-manager.h              |    5 ++
 clutter/clutter-stage.h                      |   35 ++++++++++
 clutter/clutter-swipe-action.h               |    2 +
 clutter/clutter-text.h                       |   67 +++++++++++++++++++
 clutter/clutter-texture.h                    |    2 +
 clutter/clutter-timeline.h                   |   25 +++++++
 clutter/clutter-types.h                      |   54 ++++++++++++++++
 clutter/clutter-units.h                      |   18 +++++
 clutter/clutter-version.h.in                 |    6 --
 clutter/clutter.h                            |    3 +-
 clutter/deprecated/clutter-fixed.h           |    1 +
 65 files changed, 908 insertions(+), 142 deletions(-)
---
diff --git a/clutter/clutter-action.h b/clutter/clutter-action.h
index d2e98db..dab3a3f 100644
--- a/clutter/clutter-action.h
+++ b/clutter/clutter-action.h
@@ -79,24 +79,33 @@ struct _ClutterActionClass
   void (* _clutter_action8) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_action_get_type (void) G_GNUC_CONST;
 
 /* ClutterActor API */
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_add_action            (ClutterActor  *self,
                                                     ClutterAction *action);
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_add_action_with_name  (ClutterActor  *self,
                                                     const gchar   *name,
                                                     ClutterAction *action);
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_remove_action         (ClutterActor  *self,
                                                     ClutterAction *action);
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_remove_action_by_name (ClutterActor  *self,
                                                     const gchar   *name);
+CLUTTER_AVAILABLE_IN_1_4
 ClutterAction *clutter_actor_get_action            (ClutterActor  *self,
                                                     const gchar   *name);
+CLUTTER_AVAILABLE_IN_1_4
 GList *        clutter_actor_get_actions           (ClutterActor  *self);
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_clear_actions         (ClutterActor  *self);
 
-gboolean        clutter_actor_has_actions          (ClutterActor  *self);
+CLUTTER_AVAILABLE_IN_1_10
+gboolean       clutter_actor_has_actions           (ClutterActor  *self);
 
 G_END_DECLS
 
diff --git a/clutter/clutter-actor-meta.h b/clutter/clutter-actor-meta.h
index fa3fafe..1f7baea 100644
--- a/clutter/clutter-actor-meta.h
+++ b/clutter/clutter-actor-meta.h
@@ -97,15 +97,21 @@ struct _ClutterActorMetaClass
   void (* _clutter_meta7) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_actor_meta_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_actor_meta_set_name     (ClutterActorMeta *meta,
                                                  const gchar      *name);
+CLUTTER_AVAILABLE_IN_1_4
 const gchar *   clutter_actor_meta_get_name     (ClutterActorMeta *meta);
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_actor_meta_set_enabled  (ClutterActorMeta *meta,
                                                  gboolean          is_enabled);
+CLUTTER_AVAILABLE_IN_1_4
 gboolean        clutter_actor_meta_get_enabled  (ClutterActorMeta *meta);
 
+CLUTTER_AVAILABLE_IN_1_4
 ClutterActor *  clutter_actor_meta_get_actor    (ClutterActorMeta *meta);
 
 G_END_DECLS
diff --git a/clutter/clutter-actor.c b/clutter/clutter-actor.c
index 1a317a2..2274c3e 100644
--- a/clutter/clutter-actor.c
+++ b/clutter/clutter-actor.c
@@ -579,9 +579,7 @@
  * Since: 0.6
  */
 
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
 #include <math.h>
 
diff --git a/clutter/clutter-actor.h b/clutter/clutter-actor.h
index bfcb727..b4c1136 100644
--- a/clutter/clutter-actor.h
+++ b/clutter/clutter-actor.h
@@ -298,62 +298,90 @@ struct _ClutterActorIter
   gpointer CLUTTER_PRIVATE_FIELD (dummy5);
 };
 
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_actor_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_new                               (void);
 
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_flags                         (ClutterActor                
*self,
                                                                                  ClutterActorFlags           
 flags);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_unset_flags                       (ClutterActor                
*self,
                                                                                  ClutterActorFlags           
 flags);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActorFlags               clutter_actor_get_flags                         (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_show                              (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_hide                              (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_realize                           (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_unrealize                         (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_map                               (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_unmap                             (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_paint                             (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_continue_paint                    (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_queue_redraw                      (ClutterActor                
*self);
 CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_queue_redraw_with_clip            (ClutterActor                
*self,
                                                                                  const cairo_rectangle_int_t 
*clip);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_queue_relayout                    (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_destroy                           (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_name                          (ClutterActor                
*self,
                                                                                  const gchar                 
*name);
+CLUTTER_AVAILABLE_IN_ALL
 const gchar *                   clutter_actor_get_name                          (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 AtkObject *                     clutter_actor_get_accessible                    (ClutterActor                
*self);
 
 /* Size negotiation */
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_request_mode                  (ClutterActor                
*self,
                                                                                  ClutterRequestMode          
 mode);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterRequestMode              clutter_actor_get_request_mode                  (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_preferred_width               (ClutterActor                
*self,
                                                                                  gfloat                      
 for_height,
                                                                                  gfloat                      
*min_width_p,
                                                                                  gfloat                      
*natural_width_p);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_preferred_height              (ClutterActor                
*self,
                                                                                  gfloat                      
 for_width,
                                                                                  gfloat                      
*min_height_p,
                                                                                  gfloat                      
*natural_height_p);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_preferred_size                (ClutterActor                
*self,
                                                                                  gfloat                      
*min_width_p,
                                                                                  gfloat                      
*min_height_p,
                                                                                  gfloat                      
*natural_width_p,
                                                                                  gfloat                      
*natural_height_p);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_allocate                          (ClutterActor                
*self,
                                                                                  const ClutterActorBox       
*box,
                                                                                  ClutterAllocationFlags      
 flags);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_allocate_preferred_size           (ClutterActor                
*self,
                                                                                  ClutterAllocationFlags      
 flags);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_allocate_available_size           (ClutterActor                
*self,
                                                                                  gfloat                      
 x,
                                                                                  gfloat                      
 y,
                                                                                  gfloat                      
 available_width,
                                                                                  gfloat                      
 available_height,
                                                                                  ClutterAllocationFlags      
 flags);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_allocate_align_fill               (ClutterActor                
*self,
                                                                                  const ClutterActorBox       
*box,
                                                                                  gdouble                     
 x_align,
@@ -361,45 +389,64 @@ void                            clutter_actor_allocate_align_fill
                                                                                  gboolean                    
 x_fill,
                                                                                  gboolean                    
 y_fill,
                                                                                  ClutterAllocationFlags      
 flags);
+CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_allocation                    (ClutterActor                
*self,
                                                                                  const ClutterActorBox       
*box,
                                                                                  ClutterAllocationFlags      
 flags);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_allocation_box                (ClutterActor                
*self,
                                                                                  ClutterActorBox             
*box);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_allocation_vertices           (ClutterActor                
*self,
                                                                                  ClutterActor                
*ancestor,
                                                                                  ClutterVertex               
 verts[]);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_has_allocation                    (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_size                          (ClutterActor                
*self,
                                                                                  gfloat                      
 width,
                                                                                  gfloat                      
 height);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_size                          (ClutterActor                
*self,
                                                                                  gfloat                      
*width,
                                                                                  gfloat                      
*height);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_position                      (ClutterActor                
*self,
                                                                                  gfloat                      
 x,
                                                                                  gfloat                      
 y);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_position                      (ClutterActor                
*self,
                                                                                  gfloat                      
*x,
                                                                                  gfloat                      
*y);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_fixed_position_set            (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_fixed_position_set            (ClutterActor                
*self,
                                                                                  gboolean                    
 is_set);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_move_by                           (ClutterActor                
*self,
                                                                                  gfloat                      
 dx,
                                                                                  gfloat                      
 dy);
 
 /* Actor geometry */
+CLUTTER_AVAILABLE_IN_ALL
 gfloat                          clutter_actor_get_width                         (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 gfloat                          clutter_actor_get_height                        (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_width                         (ClutterActor                
*self,
                                                                                  gfloat                      
 width);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_height                        (ClutterActor                
*self,
                                                                                  gfloat                      
 height);
+CLUTTER_AVAILABLE_IN_ALL
 gfloat                          clutter_actor_get_x                             (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 gfloat                          clutter_actor_get_y                             (ClutterActor                
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_x                             (ClutterActor                
*self,
                                                                                  gfloat                      
 x);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_y                             (ClutterActor                
*self,
                                                                                  gfloat                      
 y);
 CLUTTER_AVAILABLE_IN_1_12
@@ -463,33 +510,49 @@ gboolean                        clutter_actor_needs_expand
                                                                                  ClutterOrientation          
 orientation);
 
 /* Paint */
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_clip                          (ClutterActor                
*self,
                                                                                  gfloat                      
 xoff,
                                                                                  gfloat                      
 yoff,
                                                                                  gfloat                      
 width,
                                                                                  gfloat                      
 height);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_remove_clip                       (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_has_clip                          (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_clip                          (ClutterActor               
*self,
                                                                                  gfloat                     
*xoff,
                                                                                  gfloat                     
*yoff,
                                                                                  gfloat                     
*width,
                                                                                  gfloat                     
*height);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_clip_to_allocation            (ClutterActor               
*self,
                                                                                  gboolean                    
clip_set);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_clip_to_allocation            (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_opacity                       (ClutterActor               
*self,
                                                                                  guint8                      
opacity);
+CLUTTER_AVAILABLE_IN_ALL
 guint8                          clutter_actor_get_opacity                       (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_ALL
 guint8                          clutter_actor_get_paint_opacity                 (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_paint_visibility              (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_1_8
 void                            clutter_actor_set_offscreen_redirect            (ClutterActor               
*self,
                                                                                  ClutterOffscreenRedirect    
redirect);
+CLUTTER_AVAILABLE_IN_1_8
 ClutterOffscreenRedirect        clutter_actor_get_offscreen_redirect            (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_should_pick_paint                 (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_is_in_clone_paint                 (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_paint_box                     (ClutterActor               
*self,
                                                                                  ClutterActorBox            
*box);
+CLUTTER_AVAILABLE_IN_1_8
 gboolean                        clutter_actor_has_overlaps                      (ClutterActor               
*self);
 
 /* Content */
@@ -525,30 +588,43 @@ void                            clutter_actor_set_background_color
 CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_get_background_color              (ClutterActor               
*self,
                                                                                  ClutterColor               
*color);
+CLUTTER_AVAILABLE_IN_1_6
 const ClutterPaintVolume *      clutter_actor_get_paint_volume                  (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_1_6
 const ClutterPaintVolume *      clutter_actor_get_transformed_paint_volume      (ClutterActor               
*self,
                                                                                  ClutterActor               
*relative_to_ancestor);
 CLUTTER_AVAILABLE_IN_1_10
 const ClutterPaintVolume *      clutter_actor_get_default_paint_volume          (ClutterActor               
*self);
 
 /* Events */
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_reactive                      (ClutterActor               
*actor,
                                                                                  gboolean                    
reactive);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_get_reactive                      (ClutterActor               
*actor);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_has_key_focus                     (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_grab_key_focus                    (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_event                             (ClutterActor               
*actor,
                                                                                  const ClutterEvent         
*event,
                                                                                  gboolean                    
capture);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_has_pointer                       (ClutterActor               
*self);
 
 /* Text */
+CLUTTER_AVAILABLE_IN_ALL
 PangoContext *                  clutter_actor_get_pango_context                 (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_ALL
 PangoContext *                  clutter_actor_create_pango_context              (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_ALL
 PangoLayout *                   clutter_actor_create_pango_layout               (ClutterActor               
*self,
                                                                                  const gchar                
*text);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_text_direction                (ClutterActor               
*self,
                                                                                  ClutterTextDirection        
text_dir);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterTextDirection            clutter_actor_get_text_direction                (ClutterActor               
*self);
 
 /* Actor hierarchy */
@@ -593,9 +669,12 @@ CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_get_first_child                   (ClutterActor               
*self);
 CLUTTER_AVAILABLE_IN_1_10
 ClutterActor *                  clutter_actor_get_last_child                    (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor *                  clutter_actor_get_parent                        (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_1_4
 gboolean                        clutter_actor_contains                          (ClutterActor               
*self,
                                                                                  ClutterActor               
*descendant);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor*                   clutter_actor_get_stage                         (ClutterActor               
*actor);
 CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_actor_set_child_below_sibling           (ClutterActor               
*self,
@@ -626,7 +705,9 @@ CLUTTER_AVAILABLE_IN_1_12
 gboolean                        clutter_actor_iter_is_valid                     (const ClutterActorIter     
*iter);
 
 /* Transformations */
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_is_rotated                        (ClutterActor               
*self);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_is_scaled                         (ClutterActor               
*self);
 CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_set_pivot_point                   (ClutterActor               
*self,
@@ -648,9 +729,11 @@ void                            clutter_actor_set_rotation_angle
 CLUTTER_AVAILABLE_IN_1_12
 gdouble                         clutter_actor_get_rotation_angle                (ClutterActor               
*self,
                                                                                  ClutterRotateAxis           
axis);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_set_scale                         (ClutterActor               
*self,
                                                                                  gdouble                     
scale_x,
                                                                                  gdouble                     
scale_y);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_scale                         (ClutterActor               
*self,
                                                                                  gdouble                    
*scale_x,
                                                                                  gdouble                    
*scale_y);
@@ -681,22 +764,28 @@ void                            clutter_actor_set_child_transform
 CLUTTER_AVAILABLE_IN_1_12
 void                            clutter_actor_get_child_transform               (ClutterActor               
*self,
                                                                                  ClutterMatrix              
*transform);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_transformed_position          (ClutterActor               
*self,
                                                                                  gfloat                     
*x,
                                                                                  gfloat                     
*y);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_transformed_size              (ClutterActor               
*self,
                                                                                  gfloat                     
*width,
                                                                                  gfloat                     
*height);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_actor_transform_stage_point             (ClutterActor               
*self,
                                                                                  gfloat                      
x,
                                                                                  gfloat                      
y,
                                                                                  gfloat                     
*x_out,
                                                                                  gfloat                     
*y_out);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_get_abs_allocation_vertices       (ClutterActor               
*self,
                                                                                  ClutterVertex               
verts[]);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_apply_transform_to_point          (ClutterActor               
*self,
                                                                                  const ClutterVertex        
*point,
                                                                                  ClutterVertex              
*vertex);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_actor_apply_relative_transform_to_point (ClutterActor               
*self,
                                                                                  ClutterActor               
*ancestor,
                                                                                  const ClutterVertex        
*point,
diff --git a/clutter/clutter-align-constraint.h b/clutter/clutter-align-constraint.h
index 6ff855e..7d92ce1 100644
--- a/clutter/clutter-align-constraint.h
+++ b/clutter/clutter-align-constraint.h
@@ -48,20 +48,28 @@ G_BEGIN_DECLS
 typedef struct _ClutterAlignConstraint          ClutterAlignConstraint;
 typedef struct _ClutterAlignConstraintClass     ClutterAlignConstraintClass;
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_align_constraint_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_4
 ClutterConstraint *clutter_align_constraint_new            (ClutterActor           *source,
                                                             ClutterAlignAxis        axis,
                                                             gfloat                  factor);
 
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_align_constraint_set_source     (ClutterAlignConstraint *align,
                                                             ClutterActor           *source);
+CLUTTER_AVAILABLE_IN_1_4
 ClutterActor *     clutter_align_constraint_get_source     (ClutterAlignConstraint *align);
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_align_constraint_set_align_axis (ClutterAlignConstraint *align,
                                                             ClutterAlignAxis        axis);
+CLUTTER_AVAILABLE_IN_1_4
 ClutterAlignAxis   clutter_align_constraint_get_align_axis (ClutterAlignConstraint *align);
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_align_constraint_set_factor     (ClutterAlignConstraint *align,
                                                             gfloat                  factor);
+CLUTTER_AVAILABLE_IN_1_4
 gfloat             clutter_align_constraint_get_factor     (ClutterAlignConstraint *align);
 
 G_END_DECLS
diff --git a/clutter/clutter-animatable.h b/clutter/clutter-animatable.h
index 78a796f..7d20c5a 100644
--- a/clutter/clutter-animatable.h
+++ b/clutter/clutter-animatable.h
@@ -95,16 +95,21 @@ struct _ClutterAnimatableIface
                                      GValue            *value);
 };
 
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_animatable_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_0
 GParamSpec *clutter_animatable_find_property     (ClutterAnimatable *animatable,
                                                   const gchar       *property_name);
+CLUTTER_AVAILABLE_IN_1_0
 void        clutter_animatable_get_initial_state (ClutterAnimatable *animatable,
                                                   const gchar       *property_name,
                                                   GValue            *value);
+CLUTTER_AVAILABLE_IN_1_0
 void        clutter_animatable_set_final_state   (ClutterAnimatable *animatable,
                                                   const gchar       *property_name,
                                                   const GValue      *value);
+CLUTTER_AVAILABLE_IN_1_8
 gboolean    clutter_animatable_interpolate_value (ClutterAnimatable *animatable,
                                                   const gchar       *property_name,
                                                   ClutterInterval   *interval,
diff --git a/clutter/clutter-backend.h b/clutter/clutter-backend.h
index 8f900b7..c28a31a 100644
--- a/clutter/clutter-backend.h
+++ b/clutter/clutter-backend.h
@@ -55,21 +55,27 @@ G_BEGIN_DECLS
 typedef struct _ClutterBackend          ClutterBackend;
 typedef struct _ClutterBackendClass     ClutterBackendClass;
 
-GType clutter_backend_get_type    (void) G_GNUC_CONST;
+CLUTTER_AVAILABLE_IN_ALL
+GType clutter_backend_get_type (void) G_GNUC_CONST;
 
-ClutterBackend *clutter_get_default_backend (void);
+CLUTTER_AVAILABLE_IN_ALL
+ClutterBackend *                clutter_get_default_backend             (void);
 
 CLUTTER_AVAILABLE_IN_1_16
-void           clutter_set_windowing_backend (const char *backend_type);
+void                            clutter_set_windowing_backend           (const char *backend_type);
 
-gdouble                     clutter_backend_get_resolution            (ClutterBackend             *backend);
+CLUTTER_AVAILABLE_IN_ALL
+gdouble                         clutter_backend_get_resolution          (ClutterBackend             
*backend);
 
-void                        clutter_backend_set_font_options          (ClutterBackend             *backend,
-                                                                       const cairo_font_options_t *options);
-const cairo_font_options_t *clutter_backend_get_font_options          (ClutterBackend             *backend);
+CLUTTER_AVAILABLE_IN_ALL
+void                            clutter_backend_set_font_options        (ClutterBackend             *backend,
+                                                                         const cairo_font_options_t 
*options);
+CLUTTER_AVAILABLE_IN_ALL
+const cairo_font_options_t *    clutter_backend_get_font_options        (ClutterBackend             
*backend);
 
 #if defined (COGL_ENABLE_EXPERIMENTAL_API) && defined (CLUTTER_ENABLE_EXPERIMENTAL_API)
-CoglContext                *clutter_backend_get_cogl_context          (ClutterBackend             *backend);
+CLUTTER_AVAILABLE_IN_1_8
+CoglContext *                   clutter_backend_get_cogl_context        (ClutterBackend             
*backend);
 #endif
 
 G_END_DECLS
diff --git a/clutter/clutter-bin-layout.h b/clutter/clutter-bin-layout.h
index 6f52ba1..fc89e0b 100644
--- a/clutter/clutter-bin-layout.h
+++ b/clutter/clutter-bin-layout.h
@@ -74,10 +74,12 @@ struct _ClutterBinLayoutClass
   ClutterLayoutManagerClass parent_class;
 };
 
+CLUTTER_AVAILABLE_IN_1_2
 GType clutter_bin_layout_get_type (void) G_GNUC_CONST;
 
-ClutterLayoutManager *clutter_bin_layout_new           (ClutterBinAlignment  x_align,
-                                                        ClutterBinAlignment  y_align);
+CLUTTER_AVAILABLE_IN_1_2
+ClutterLayoutManager *  clutter_bin_layout_new  (ClutterBinAlignment x_align,
+                                                 ClutterBinAlignment y_align);
 
 G_END_DECLS
 
diff --git a/clutter/clutter-bind-constraint.h b/clutter/clutter-bind-constraint.h
index 3ce1d59..66f4f64 100644
--- a/clutter/clutter-bind-constraint.h
+++ b/clutter/clutter-bind-constraint.h
@@ -48,20 +48,28 @@ G_BEGIN_DECLS
 typedef struct _ClutterBindConstraint           ClutterBindConstraint;
 typedef struct _ClutterBindConstraintClass      ClutterBindConstraintClass;
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_bind_constraint_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_4
 ClutterConstraint *   clutter_bind_constraint_new            (ClutterActor          *source,
                                                               ClutterBindCoordinate  coordinate,
                                                               gfloat                 offset);
 
+CLUTTER_AVAILABLE_IN_1_4
 void                  clutter_bind_constraint_set_source     (ClutterBindConstraint *constraint,
                                                               ClutterActor          *source);
+CLUTTER_AVAILABLE_IN_1_4
 ClutterActor *        clutter_bind_constraint_get_source     (ClutterBindConstraint *constraint);
+CLUTTER_AVAILABLE_IN_1_4
 void                  clutter_bind_constraint_set_coordinate (ClutterBindConstraint *constraint,
                                                               ClutterBindCoordinate  coordinate);
+CLUTTER_AVAILABLE_IN_1_4
 ClutterBindCoordinate clutter_bind_constraint_get_coordinate (ClutterBindConstraint *constraint);
+CLUTTER_AVAILABLE_IN_1_4
 void                  clutter_bind_constraint_set_offset     (ClutterBindConstraint *constraint,
                                                               gfloat                 offset);
+CLUTTER_AVAILABLE_IN_1_4
 gfloat                clutter_bind_constraint_get_offset     (ClutterBindConstraint *constraint);
 
 G_END_DECLS
diff --git a/clutter/clutter-binding-pool.h b/clutter/clutter-binding-pool.h
index cdba037..6df5260 100644
--- a/clutter/clutter-binding-pool.h
+++ b/clutter/clutter-binding-pool.h
@@ -71,12 +71,17 @@ typedef gboolean (* ClutterBindingActionFunc) (GObject             *gobject,
                                                ClutterModifierType  modifiers,
                                                gpointer             user_data);
 
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_binding_pool_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_0
 ClutterBindingPool *  clutter_binding_pool_new              (const gchar         *name);
+CLUTTER_AVAILABLE_IN_1_0
 ClutterBindingPool *  clutter_binding_pool_get_for_class    (gpointer             klass);
+CLUTTER_AVAILABLE_IN_1_0
 ClutterBindingPool *  clutter_binding_pool_find             (const gchar         *name);
 
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_install_action   (ClutterBindingPool  *pool,
                                                              const gchar         *action_name,
                                                              guint                key_val,
@@ -84,36 +89,44 @@ void                  clutter_binding_pool_install_action   (ClutterBindingPool
                                                              GCallback            callback,
                                                              gpointer             data,
                                                              GDestroyNotify       notify);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_install_closure  (ClutterBindingPool  *pool,
                                                              const gchar         *action_name,
                                                              guint                key_val,
                                                              ClutterModifierType  modifiers,
                                                              GClosure            *closure);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_override_action  (ClutterBindingPool  *pool,
                                                              guint                key_val,
                                                              ClutterModifierType  modifiers,
                                                              GCallback            callback,
                                                              gpointer             data,
                                                              GDestroyNotify       notify);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_override_closure (ClutterBindingPool  *pool,
                                                              guint                key_val,
                                                              ClutterModifierType  modifiers,
                                                              GClosure            *closure);
 
+CLUTTER_AVAILABLE_IN_1_0
 const gchar *         clutter_binding_pool_find_action      (ClutterBindingPool  *pool,
                                                              guint                key_val,
                                                              ClutterModifierType  modifiers);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_remove_action    (ClutterBindingPool  *pool,
                                                              guint                key_val,
                                                              ClutterModifierType  modifiers);
 
+CLUTTER_AVAILABLE_IN_1_0
 gboolean              clutter_binding_pool_activate         (ClutterBindingPool  *pool,
                                                              guint                key_val,
                                                              ClutterModifierType  modifiers,
                                                              GObject             *gobject);
 
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_block_action     (ClutterBindingPool  *pool,
                                                              const gchar         *action_name);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_binding_pool_unblock_action   (ClutterBindingPool  *pool,
                                                              const gchar         *action_name);
 
diff --git a/clutter/clutter-blur-effect.h b/clutter/clutter-blur-effect.h
index 27466bb..833da6b 100644
--- a/clutter/clutter-blur-effect.h
+++ b/clutter/clutter-blur-effect.h
@@ -48,8 +48,10 @@ G_BEGIN_DECLS
 typedef struct _ClutterBlurEffect       ClutterBlurEffect;
 typedef struct _ClutterBlurEffectClass  ClutterBlurEffectClass;
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_blur_effect_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_4
 ClutterEffect *clutter_blur_effect_new (void);
 
 G_END_DECLS
diff --git a/clutter/clutter-box-layout.h b/clutter/clutter-box-layout.h
index 32daca8..3c5547e 100644
--- a/clutter/clutter-box-layout.h
+++ b/clutter/clutter-box-layout.h
@@ -77,8 +77,10 @@ struct _ClutterBoxLayoutClass
   ClutterLayoutManagerClass parent_class;
 };
 
+CLUTTER_AVAILABLE_IN_1_2
 GType clutter_box_layout_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_2
 ClutterLayoutManager *  clutter_box_layout_new                 (void);
 
 CLUTTER_AVAILABLE_IN_1_12
@@ -87,14 +89,20 @@ void                    clutter_box_layout_set_orientation      (ClutterBoxLayou
 CLUTTER_AVAILABLE_IN_1_12
 ClutterOrientation      clutter_box_layout_get_orientation      (ClutterBoxLayout    *layout);
 
+CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_box_layout_set_spacing          (ClutterBoxLayout    *layout,
                                                                  guint                spacing);
+CLUTTER_AVAILABLE_IN_1_2
 guint                   clutter_box_layout_get_spacing          (ClutterBoxLayout    *layout);
+CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_box_layout_set_homogeneous      (ClutterBoxLayout    *layout,
                                                                  gboolean             homogeneous);
+CLUTTER_AVAILABLE_IN_1_2
 gboolean                clutter_box_layout_get_homogeneous      (ClutterBoxLayout    *layout);
+CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_box_layout_set_pack_start       (ClutterBoxLayout    *layout,
                                                                  gboolean             pack_start);
+CLUTTER_AVAILABLE_IN_1_2
 gboolean                clutter_box_layout_get_pack_start       (ClutterBoxLayout    *layout);
 
 CLUTTER_DEPRECATED_IN_1_12_FOR(clutter_box_layout_set_orientation)
@@ -103,6 +111,7 @@ void                    clutter_box_layout_set_vertical         (ClutterBoxLayou
 CLUTTER_DEPRECATED_IN_1_12_FOR(clutter_box_layout_get_orientation)
 gboolean                clutter_box_layout_get_vertical         (ClutterBoxLayout    *layout);
 
+CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_box_layout_pack                 (ClutterBoxLayout    *layout,
                                                                  ClutterActor        *actor,
                                                                  gboolean             expand,
diff --git a/clutter/clutter-brightness-contrast-effect.h b/clutter/clutter-brightness-contrast-effect.h
index b4b3a40..d7d3ed6 100644
--- a/clutter/clutter-brightness-contrast-effect.h
+++ b/clutter/clutter-brightness-contrast-effect.h
@@ -49,27 +49,35 @@ G_BEGIN_DECLS
 typedef struct _ClutterBrightnessContrastEffect         ClutterBrightnessContrastEffect;
 typedef struct _ClutterBrightnessContrastEffectClass    ClutterBrightnessContrastEffectClass;
 
+CLUTTER_AVAILABLE_IN_1_10
 GType clutter_brightness_contrast_effect_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_10
 ClutterEffect * clutter_brightness_contrast_effect_new                          (void);
 
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_set_brightness_full          
(ClutterBrightnessContrastEffect *effect,
                                                                                  float                       
     red,
                                                                                  float                       
     green,
                                                                                  float                       
     blue);
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_set_brightness               
(ClutterBrightnessContrastEffect *effect,
                                                                                  float                       
     brightness);
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_get_brightness               
(ClutterBrightnessContrastEffect *effect,
                                                                                  float                       
    *red,
                                                                                  float                       
    *green,
                                                                                  float                       
    *blue);
 
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_set_contrast_full            
(ClutterBrightnessContrastEffect *effect,
                                                                                  float                       
     red,
                                                                                  float                       
     green,
                                                                                  float                       
     blue);
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_set_contrast                 
(ClutterBrightnessContrastEffect *effect,
                                                                                  float                       
     contrast);
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_brightness_contrast_effect_get_contrast                 
(ClutterBrightnessContrastEffect *effect,
                                                                                  float                       
    *red,
                                                                                  float                       
    *green,
diff --git a/clutter/clutter-cairo.h b/clutter/clutter-cairo.h
index f6bd9d8..993b3e1 100644
--- a/clutter/clutter-cairo.h
+++ b/clutter/clutter-cairo.h
@@ -50,7 +50,9 @@ G_BEGIN_DECLS
 #define CLUTTER_CAIRO_FORMAT_ARGB32     (COGL_PIXEL_FORMAT_ARGB_8888_PRE)
 #endif
 
+CLUTTER_AVAILABLE_IN_1_12
 void    clutter_cairo_clear             (cairo_t               *cr);
+CLUTTER_AVAILABLE_IN_1_0
 void    clutter_cairo_set_source_color  (cairo_t               *cr,
                                          const ClutterColor    *color);
 
diff --git a/clutter/clutter-child-meta.h b/clutter/clutter-child-meta.h
index 0a249f0..df6246c 100644
--- a/clutter/clutter-child-meta.h
+++ b/clutter/clutter-child-meta.h
@@ -110,10 +110,13 @@ struct _ClutterChildMetaClass
   GObjectClass parent_class;
 }; 
 
-GType             clutter_child_meta_get_type      (void) G_GNUC_CONST;
+CLUTTER_AVAILABLE_IN_ALL
+GType clutter_child_meta_get_type (void) G_GNUC_CONST;
 
-ClutterContainer *clutter_child_meta_get_container (ClutterChildMeta *data);
-ClutterActor     *clutter_child_meta_get_actor     (ClutterChildMeta *data);
+CLUTTER_AVAILABLE_IN_ALL
+ClutterContainer *      clutter_child_meta_get_container        (ClutterChildMeta *data);
+CLUTTER_AVAILABLE_IN_ALL
+ClutterActor     *      clutter_child_meta_get_actor            (ClutterChildMeta *data);
 
 G_END_DECLS
 
diff --git a/clutter/clutter-click-action.h b/clutter/clutter-click-action.h
index 36c5727..fefe0e6 100644
--- a/clutter/clutter-click-action.h
+++ b/clutter/clutter-click-action.h
@@ -97,16 +97,22 @@ struct _ClutterClickActionClass
   void (* _clutter_click_action7) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_click_action_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_4
 ClutterAction *        clutter_click_action_new        (void);
 
+CLUTTER_AVAILABLE_IN_1_4
 guint                  clutter_click_action_get_button (ClutterClickAction *action);
+CLUTTER_AVAILABLE_IN_1_4
 ClutterModifierType    clutter_click_action_get_state  (ClutterClickAction *action);
+CLUTTER_AVAILABLE_IN_1_8
 void                   clutter_click_action_get_coords (ClutterClickAction *action,
                                                         gfloat             *press_x,
                                                         gfloat             *press_y);
 
+CLUTTER_AVAILABLE_IN_1_4
 void                   clutter_click_action_release    (ClutterClickAction *action);
 
 G_END_DECLS
diff --git a/clutter/clutter-clone.h b/clutter/clutter-clone.h
index 14fef88..24958de 100644
--- a/clutter/clutter-clone.h
+++ b/clutter/clutter-clone.h
@@ -78,12 +78,16 @@ struct _ClutterCloneClass
   void (*_clutter_actor_clone4) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_clone_get_type (void) G_GNUC_CONST;
 
-ClutterActor *clutter_clone_new        (ClutterActor *source);
-void          clutter_clone_set_source (ClutterClone *self,
-                                        ClutterActor *source);
-ClutterActor *clutter_clone_get_source (ClutterClone *self);
+CLUTTER_AVAILABLE_IN_1_0
+ClutterActor *  clutter_clone_new               (ClutterActor *source);
+CLUTTER_AVAILABLE_IN_1_0
+void            clutter_clone_set_source        (ClutterClone *self,
+                                                 ClutterActor *source);
+CLUTTER_AVAILABLE_IN_1_0
+ClutterActor *  clutter_clone_get_source        (ClutterClone *self);
 
 G_END_DECLS
 
diff --git a/clutter/clutter-color.h b/clutter/clutter-color.h
index 393eee4..cd8e5cc 100644
--- a/clutter/clutter-color.h
+++ b/clutter/clutter-color.h
@@ -68,56 +68,76 @@ struct _ClutterColor
  */
 #define CLUTTER_COLOR_INIT(r,g,b,a)     { (r), (g), (b), (a) }
 
-GType         clutter_color_get_type   (void) G_GNUC_CONST;
+CLUTTER_AVAILABLE_IN_ALL
+GType clutter_color_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_ALL
 ClutterColor *clutter_color_new         (guint8              red,
                                          guint8              green,
                                          guint8              blue,
                                          guint8              alpha);
+CLUTTER_AVAILABLE_IN_1_12
 ClutterColor *clutter_color_alloc       (void);
+CLUTTER_AVAILABLE_IN_1_12
 ClutterColor *clutter_color_init        (ClutterColor       *color,
                                          guint8              red,
                                          guint8              green,
                                          guint8              blue,
                                          guint8              alpha);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterColor *clutter_color_copy        (const ClutterColor *color);
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_free        (ClutterColor       *color);
 
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_add         (const ClutterColor *a,
                                          const ClutterColor *b,
                                          ClutterColor       *result);
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_subtract    (const ClutterColor *a,
                                          const ClutterColor *b,
                                          ClutterColor       *result);
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_lighten     (const ClutterColor *color,
                                          ClutterColor       *result);
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_darken      (const ClutterColor *color,
                                          ClutterColor       *result);
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_shade       (const ClutterColor *color,
                                          gdouble             factor,
                                          ClutterColor       *result);
 
+CLUTTER_AVAILABLE_IN_ALL
 gchar *       clutter_color_to_string   (const ClutterColor *color);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean      clutter_color_from_string (ClutterColor       *color,
                                          const gchar        *str);
 
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_to_hls      (const ClutterColor *color,
                                          gfloat             *hue,
                                         gfloat             *luminance,
                                         gfloat             *saturation);
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_from_hls    (ClutterColor       *color,
                                          gfloat              hue,
                                          gfloat              luminance,
                                          gfloat              saturation);
 
+CLUTTER_AVAILABLE_IN_ALL
 guint32       clutter_color_to_pixel    (const ClutterColor *color);
+CLUTTER_AVAILABLE_IN_ALL
 void          clutter_color_from_pixel  (ClutterColor       *color,
                                          guint32             pixel);
 
+CLUTTER_AVAILABLE_IN_1_0
 guint         clutter_color_hash        (gconstpointer       v);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean      clutter_color_equal       (gconstpointer       v1,
                                          gconstpointer       v2);
 
+CLUTTER_AVAILABLE_IN_1_6
 void          clutter_color_interpolate (const ClutterColor *initial,
                                          const ClutterColor *final,
                                          gdouble             progress,
@@ -157,17 +177,22 @@ struct _ClutterParamSpecColor
   ClutterColor *default_value;
 };
 
+CLUTTER_AVAILABLE_IN_1_0
 void                    clutter_value_set_color         (GValue             *value,
                                                          const ClutterColor *color);
+CLUTTER_AVAILABLE_IN_1_0
 const ClutterColor *    clutter_value_get_color         (const GValue       *value);
 
-GType       clutter_param_color_get_type (void) G_GNUC_CONST;
-GParamSpec *clutter_param_spec_color     (const gchar        *name,
-                                          const gchar        *nick,
-                                          const gchar        *blurb,
-                                          const ClutterColor *default_value,
-                                          GParamFlags         flags);
+CLUTTER_AVAILABLE_IN_1_0
+GType clutter_param_color_get_type (void) G_GNUC_CONST;
+CLUTTER_AVAILABLE_IN_1_0
+GParamSpec *    clutter_param_spec_color        (const gchar        *name,
+                                                 const gchar        *nick,
+                                                 const gchar        *blurb,
+                                                 const ClutterColor *default_value,
+                                                 GParamFlags         flags);
 
+CLUTTER_AVAILABLE_IN_1_6
 const ClutterColor *clutter_color_get_static (ClutterStaticColor color);
 
 G_END_DECLS
diff --git a/clutter/clutter-colorize-effect.h b/clutter/clutter-colorize-effect.h
index ddc761f..603ed7c 100644
--- a/clutter/clutter-colorize-effect.h
+++ b/clutter/clutter-colorize-effect.h
@@ -49,12 +49,16 @@ G_BEGIN_DECLS
 typedef struct _ClutterColorizeEffect           ClutterColorizeEffect;
 typedef struct _ClutterColorizeEffectClass      ClutterColorizeEffectClass;
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_colorize_effect_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_4
 ClutterEffect *clutter_colorize_effect_new      (const ClutterColor *tint);
 
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_colorize_effect_set_tint (ClutterColorizeEffect *effect,
                                                  const ClutterColor    *tint);
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_colorize_effect_get_tint (ClutterColorizeEffect *effect,
                                                  ClutterColor          *tint);
 
diff --git a/clutter/clutter-constraint.h b/clutter/clutter-constraint.h
index 777df55..6c7563d 100644
--- a/clutter/clutter-constraint.h
+++ b/clutter/clutter-constraint.h
@@ -84,23 +84,32 @@ struct _ClutterConstraintClass
   void (* _clutter_constraint8) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_constraint_get_type (void) G_GNUC_CONST;
 
 /* ClutterActor API */
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_actor_add_constraint            (ClutterActor      *self,
                                                             ClutterConstraint *constraint);
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_actor_add_constraint_with_name  (ClutterActor      *self,
                                                             const gchar       *name,
                                                             ClutterConstraint *constraint);
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_actor_remove_constraint         (ClutterActor      *self,
                                                             ClutterConstraint *constraint);
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_actor_remove_constraint_by_name (ClutterActor      *self,
                                                             const gchar       *name);
+CLUTTER_AVAILABLE_IN_1_4
 GList *            clutter_actor_get_constraints           (ClutterActor      *self);
+CLUTTER_AVAILABLE_IN_1_4
 ClutterConstraint *clutter_actor_get_constraint            (ClutterActor      *self,
                                                             const gchar       *name);
+CLUTTER_AVAILABLE_IN_1_4
 void               clutter_actor_clear_constraints         (ClutterActor      *self);
 
+CLUTTER_AVAILABLE_IN_1_10
 gboolean           clutter_actor_has_constraints           (ClutterActor *self);
 
 G_END_DECLS
diff --git a/clutter/clutter-container.h b/clutter/clutter-container.h
index b7e3f2b..990ffb7 100644
--- a/clutter/clutter-container.h
+++ b/clutter/clutter-container.h
@@ -141,43 +141,55 @@ struct _ClutterContainerIface
                           GParamSpec       *pspec);
 };
 
-GType         clutter_container_get_type         (void) G_GNUC_CONST;
-
-ClutterActor *clutter_container_find_child_by_name     (ClutterContainer *container,
-                                                        const gchar      *child_name);
-
-GParamSpec *      clutter_container_class_find_child_property   (GObjectClass     *klass,
-                                                                 const gchar      *property_name);
-GParamSpec **     clutter_container_class_list_child_properties (GObjectClass     *klass,
-                                                                 guint            *n_properties);
-
-void              clutter_container_create_child_meta           (ClutterContainer *container,
-                                                                 ClutterActor     *actor);
-void              clutter_container_destroy_child_meta          (ClutterContainer *container,
-                                                                 ClutterActor     *actor);
-ClutterChildMeta *clutter_container_get_child_meta              (ClutterContainer *container,
-                                                                 ClutterActor     *actor);
-
-void              clutter_container_child_set_property          (ClutterContainer *container,
-                                                                 ClutterActor     *child,
-                                                                 const gchar      * property,
-                                                                 const GValue     *value);
-void              clutter_container_child_get_property          (ClutterContainer *container,
-                                                                 ClutterActor     *child,
-                                                                 const gchar      *property,
-                                                                 GValue           *value);
-void              clutter_container_child_set                   (ClutterContainer *container,
-                                                                 ClutterActor     *actor,
-                                                                 const gchar      *first_prop,
-                                                                 ...) G_GNUC_NULL_TERMINATED;
-void              clutter_container_child_get                   (ClutterContainer *container,
-                                                                 ClutterActor     *actor,
-                                                                 const gchar      *first_prop,
-                                                                 ...) G_GNUC_NULL_TERMINATED;
-
-void              clutter_container_child_notify                (ClutterContainer *container,
-                                                                 ClutterActor     *child,
-                                                                 GParamSpec       *pspec);
+CLUTTER_AVAILABLE_IN_ALL
+GType clutter_container_get_type (void) G_GNUC_CONST;
+
+CLUTTER_AVAILABLE_IN_ALL
+ClutterActor *          clutter_container_find_child_by_name            (ClutterContainer *container,
+                                                                         const gchar      *child_name);
+
+CLUTTER_AVAILABLE_IN_ALL
+GParamSpec *            clutter_container_class_find_child_property     (GObjectClass     *klass,
+                                                                         const gchar      *property_name);
+CLUTTER_AVAILABLE_IN_ALL
+GParamSpec **           clutter_container_class_list_child_properties   (GObjectClass     *klass,
+                                                                         guint            *n_properties);
+
+CLUTTER_AVAILABLE_IN_ALL
+void                    clutter_container_create_child_meta             (ClutterContainer *container,
+                                                                         ClutterActor     *actor);
+CLUTTER_AVAILABLE_IN_ALL
+void                    clutter_container_destroy_child_meta            (ClutterContainer *container,
+                                                                         ClutterActor     *actor);
+CLUTTER_AVAILABLE_IN_ALL
+ClutterChildMeta *      clutter_container_get_child_meta                (ClutterContainer *container,
+                                                                         ClutterActor     *actor);
+
+CLUTTER_AVAILABLE_IN_ALL
+void                    clutter_container_child_set_property            (ClutterContainer *container,
+                                                                         ClutterActor     *child,
+                                                                         const gchar      * property,
+                                                                         const GValue     *value);
+CLUTTER_AVAILABLE_IN_ALL
+void                    clutter_container_child_get_property            (ClutterContainer *container,
+                                                                         ClutterActor     *child,
+                                                                         const gchar      *property,
+                                                                         GValue           *value);
+CLUTTER_AVAILABLE_IN_ALL
+void                    clutter_container_child_set                     (ClutterContainer *container,
+                                                                         ClutterActor     *actor,
+                                                                         const gchar      *first_prop,
+                                                                         ...) G_GNUC_NULL_TERMINATED;
+CLUTTER_AVAILABLE_IN_ALL
+void                    clutter_container_child_get                     (ClutterContainer *container,
+                                                                         ClutterActor     *actor,
+                                                                         const gchar      *first_prop,
+                                                                         ...) G_GNUC_NULL_TERMINATED;
+
+CLUTTER_AVAILABLE_IN_ALL
+void                    clutter_container_child_notify                  (ClutterContainer *container,
+                                                                         ClutterActor     *child,
+                                                                         GParamSpec       *pspec);
 
 G_END_DECLS
 
diff --git a/clutter/clutter-deform-effect.h b/clutter/clutter-deform-effect.h
index 7650e71..b122dcd 100644
--- a/clutter/clutter-deform-effect.h
+++ b/clutter/clutter-deform-effect.h
@@ -92,19 +92,25 @@ struct _ClutterDeformEffectClass
   void (*_clutter_deform7) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_deform_effect_get_type (void) G_GNUC_CONST;
 
-void       clutter_deform_effect_set_back_material (ClutterDeformEffect *effect,
-                                                    CoglHandle           material);
-CoglHandle clutter_deform_effect_get_back_material (ClutterDeformEffect *effect);
-void       clutter_deform_effect_set_n_tiles       (ClutterDeformEffect *effect,
-                                                    guint                x_tiles,
-                                                    guint                y_tiles);
-void       clutter_deform_effect_get_n_tiles       (ClutterDeformEffect *effect,
-                                                    guint               *x_tiles,
-                                                    guint               *y_tiles);
-
-void       clutter_deform_effect_invalidate        (ClutterDeformEffect *effect);
+CLUTTER_AVAILABLE_IN_1_4
+void            clutter_deform_effect_set_back_material (ClutterDeformEffect *effect,
+                                                         CoglHandle           material);
+CLUTTER_AVAILABLE_IN_1_4
+CoglHandle      clutter_deform_effect_get_back_material (ClutterDeformEffect *effect);
+CLUTTER_AVAILABLE_IN_1_4
+void            clutter_deform_effect_set_n_tiles       (ClutterDeformEffect *effect,
+                                                         guint                x_tiles,
+                                                         guint                y_tiles);
+CLUTTER_AVAILABLE_IN_1_4
+void            clutter_deform_effect_get_n_tiles       (ClutterDeformEffect *effect,
+                                                         guint               *x_tiles,
+                                                         guint               *y_tiles);
+
+CLUTTER_AVAILABLE_IN_1_4
+void            clutter_deform_effect_invalidate        (ClutterDeformEffect *effect);
 
 G_END_DECLS
 
diff --git a/clutter/clutter-desaturate-effect.h b/clutter/clutter-desaturate-effect.h
index d73ed73..daf3318 100644
--- a/clutter/clutter-desaturate-effect.h
+++ b/clutter/clutter-desaturate-effect.h
@@ -48,12 +48,16 @@ G_BEGIN_DECLS
 typedef struct _ClutterDesaturateEffect         ClutterDesaturateEffect;
 typedef struct _ClutterDesaturateEffectClass    ClutterDesaturateEffectClass;
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_desaturate_effect_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_4
 ClutterEffect *clutter_desaturate_effect_new        (gdouble                  factor);
 
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_desaturate_effect_set_factor (ClutterDesaturateEffect *effect,
                                                      gdouble                  factor);
+CLUTTER_AVAILABLE_IN_1_4
 gdouble        clutter_desaturate_effect_get_factor (ClutterDesaturateEffect *effect);
 
 G_END_DECLS
diff --git a/clutter/clutter-device-manager.h b/clutter/clutter-device-manager.h
index 49b0f94..177d452 100644
--- a/clutter/clutter-device-manager.h
+++ b/clutter/clutter-device-manager.h
@@ -88,16 +88,20 @@ struct _ClutterDeviceManagerClass
   gpointer _padding[7];
 };
 
-
-
+CLUTTER_AVAILABLE_IN_1_2
 GType clutter_device_manager_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_2
 ClutterDeviceManager *clutter_device_manager_get_default     (void);
+CLUTTER_AVAILABLE_IN_1_2
 GSList *              clutter_device_manager_list_devices    (ClutterDeviceManager   *device_manager);
+CLUTTER_AVAILABLE_IN_1_2
 const GSList *        clutter_device_manager_peek_devices    (ClutterDeviceManager   *device_manager);
 
+CLUTTER_AVAILABLE_IN_1_2
 ClutterInputDevice *  clutter_device_manager_get_device      (ClutterDeviceManager   *device_manager,
                                                               gint                    device_id);
+CLUTTER_AVAILABLE_IN_1_2
 ClutterInputDevice *  clutter_device_manager_get_core_device (ClutterDeviceManager   *device_manager,
                                                               ClutterInputDeviceType  device_type);
 
diff --git a/clutter/clutter-drag-action.h b/clutter/clutter-drag-action.h
index b2503dd..3cc52e4 100644
--- a/clutter/clutter-drag-action.h
+++ b/clutter/clutter-drag-action.h
@@ -105,26 +105,36 @@ struct _ClutterDragActionClass
   void (* _clutter_drag_action4) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_drag_action_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_4
 ClutterAction * clutter_drag_action_new                   (void);
 
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_drag_action_set_drag_threshold (ClutterDragAction *action,
                                                         gint               x_threshold,
                                                         gint               y_threshold);
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_drag_action_get_drag_threshold (ClutterDragAction *action,
                                                         guint             *x_threshold,
                                                         guint             *y_threshold);
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_drag_action_set_drag_handle    (ClutterDragAction *action,
                                                         ClutterActor      *handle);
+CLUTTER_AVAILABLE_IN_1_4
 ClutterActor *  clutter_drag_action_get_drag_handle    (ClutterDragAction *action);
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_drag_action_set_drag_axis      (ClutterDragAction *action,
                                                         ClutterDragAxis    axis);
+CLUTTER_AVAILABLE_IN_1_4
 ClutterDragAxis clutter_drag_action_get_drag_axis      (ClutterDragAction *action);
 
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_drag_action_get_press_coords   (ClutterDragAction *action,
                                                         gfloat            *press_x,
                                                         gfloat            *press_y);
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_drag_action_get_motion_coords  (ClutterDragAction *action,
                                                         gfloat            *motion_x,
                                                         gfloat            *motion_y);
diff --git a/clutter/clutter-drop-action.h b/clutter/clutter-drop-action.h
index 732baad..2877ce3 100644
--- a/clutter/clutter-drop-action.h
+++ b/clutter/clutter-drop-action.h
@@ -104,8 +104,10 @@ struct _ClutterDropActionClass
   void (*_clutter_drop_action8) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_8
 GType clutter_drop_action_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_8
 ClutterAction *         clutter_drop_action_new         (void);
 
 G_END_DECLS
diff --git a/clutter/clutter-effect.h b/clutter/clutter-effect.h
index cad4548..b5286fd 100644
--- a/clutter/clutter-effect.h
+++ b/clutter/clutter-effect.h
@@ -91,29 +91,39 @@ struct _ClutterEffectClass
   void (* _clutter_effect6) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_effect_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_8
 void    clutter_effect_queue_repaint    (ClutterEffect *effect);
 
 /*
  * ClutterActor API
  */
 
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_add_effect            (ClutterActor  *self,
                                                     ClutterEffect *effect);
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_add_effect_with_name  (ClutterActor  *self,
                                                     const gchar   *name,
                                                     ClutterEffect *effect);
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_remove_effect         (ClutterActor  *self,
                                                     ClutterEffect *effect);
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_remove_effect_by_name (ClutterActor  *self,
                                                     const gchar   *name);
+CLUTTER_AVAILABLE_IN_1_4
 GList *        clutter_actor_get_effects           (ClutterActor  *self);
+CLUTTER_AVAILABLE_IN_1_4
 ClutterEffect *clutter_actor_get_effect            (ClutterActor  *self,
                                                     const gchar   *name);
+CLUTTER_AVAILABLE_IN_1_4
 void           clutter_actor_clear_effects         (ClutterActor  *self);
 
-gboolean        clutter_actor_has_effects           (ClutterActor *self);
+CLUTTER_AVAILABLE_IN_1_10
+gboolean       clutter_actor_has_effects           (ClutterActor  *self);
 
 G_END_DECLS
 
diff --git a/clutter/clutter-enum-types.c.in b/clutter/clutter-enum-types.c.in
index 19fb9e5..39bffd4 100644
--- a/clutter/clutter-enum-types.c.in
+++ b/clutter/clutter-enum-types.c.in
@@ -1,4 +1,5 @@
 /*** BEGIN file-header ***/
+#include "config.h"
 #include "clutter-enum-types.h"
 /*** END file-header ***/
 
diff --git a/clutter/clutter-enum-types.h.in b/clutter/clutter-enum-types.h.in
index a6131c3..aea757e 100644
--- a/clutter/clutter-enum-types.h.in
+++ b/clutter/clutter-enum-types.h.in
@@ -2,7 +2,11 @@
 #ifndef __CLUTTER_ENUM_TYPES_H__
 #define __CLUTTER_ENUM_TYPES_H__
 
-#include <glib-object.h>
+#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <clutter/clutter.h> can be included directly."
+#endif
+
+#include <clutter/clutter-types.h>
 
 G_BEGIN_DECLS
 
@@ -12,15 +16,14 @@ G_BEGIN_DECLS
 /* enumerations from "@filename@" */
 /*** END file-production ***/
 
-/*** BEGIN file-tail ***/
-G_END_DECLS
-
-#endif /* !__CLUTTER_ENUM_TYPES_H__ */
-/*** END file-tail ***/
-
 /*** BEGIN value-header ***/
-GType @enum_name _get_type (void) G_GNUC_CONST;
+CLUTTER_AVAILABLE_IN_ALL GType @enum_name _get_type (void) G_GNUC_CONST;
 #define CLUTTER_TYPE_ ENUMSHORT@ (@enum_name _get_type())
 
 /*** END value-header ***/
 
+/*** BEGIN file-tail ***/
+G_END_DECLS
+
+#endif /* !__CLUTTER_ENUM_TYPES_H__ */
+/*** END file-tail ***/
diff --git a/clutter/clutter-event.h b/clutter/clutter-event.h
index f41375c..d320569 100644
--- a/clutter/clutter-event.h
+++ b/clutter/clutter-event.h
@@ -423,11 +423,16 @@ union _ClutterEvent
 typedef gboolean (* ClutterEventFilterFunc) (const ClutterEvent *event,
                                              gpointer            user_data);
 
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_event_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                clutter_events_pending                  (void);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterEvent *          clutter_event_get                       (void);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterEvent *          clutter_event_peek                      (void);
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_event_put                       (const ClutterEvent     *event);
 
 CLUTTER_AVAILABLE_IN_1_18
@@ -438,19 +443,29 @@ guint                   clutter_event_add_filter                (ClutterStage
 CLUTTER_AVAILABLE_IN_1_18
 void                    clutter_event_remove_filter             (guint                  id);
 
+CLUTTER_AVAILABLE_IN_ALL
 ClutterEvent *          clutter_event_new                       (ClutterEventType        type);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterEvent *          clutter_event_copy                      (const ClutterEvent     *event);
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_event_free                      (ClutterEvent           *event);
 
+CLUTTER_AVAILABLE_IN_ALL
 ClutterEventType        clutter_event_type                      (const ClutterEvent     *event);
+CLUTTER_AVAILABLE_IN_1_8
 void                    clutter_event_set_flags                 (ClutterEvent           *event,
                                                                  ClutterEventFlags       flags);
+CLUTTER_AVAILABLE_IN_1_0
 ClutterEventFlags       clutter_event_get_flags                 (const ClutterEvent     *event);
+CLUTTER_AVAILABLE_IN_1_8
 void                    clutter_event_set_time                  (ClutterEvent           *event,
                                                                  guint32                 time_);
+CLUTTER_AVAILABLE_IN_ALL
 guint32                 clutter_event_get_time                  (const ClutterEvent     *event);
+CLUTTER_AVAILABLE_IN_1_8
 void                    clutter_event_set_state                 (ClutterEvent           *event,
                                                                  ClutterModifierType     state);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterModifierType     clutter_event_get_state                 (const ClutterEvent     *event);
 CLUTTER_AVAILABLE_IN_1_16
 void                    clutter_event_get_state_full            (const ClutterEvent     *event,
@@ -459,26 +474,36 @@ void                    clutter_event_get_state_full            (const ClutterEv
                                                                 ClutterModifierType    *latched_state,
                                                                 ClutterModifierType    *locked_state,
                                                                 ClutterModifierType    *effective_state);
+CLUTTER_AVAILABLE_IN_1_6
 void                    clutter_event_set_device                (ClutterEvent           *event,
                                                                  ClutterInputDevice     *device);
+CLUTTER_AVAILABLE_IN_1_6
 ClutterInputDevice *    clutter_event_get_device                (const ClutterEvent     *event);
+CLUTTER_AVAILABLE_IN_1_6
 void                    clutter_event_set_source_device         (ClutterEvent           *event,
                                                                  ClutterInputDevice     *device);
 
+CLUTTER_AVAILABLE_IN_1_6
 ClutterInputDevice *    clutter_event_get_source_device         (const ClutterEvent     *event);
+CLUTTER_AVAILABLE_IN_1_8
 void                    clutter_event_set_source                (ClutterEvent           *event,
                                                                  ClutterActor           *actor);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor *          clutter_event_get_source                (const ClutterEvent     *event);
+CLUTTER_AVAILABLE_IN_1_8
 void                    clutter_event_set_stage                 (ClutterEvent           *event,
                                                                  ClutterStage           *stage);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterStage *          clutter_event_get_stage                 (const ClutterEvent     *event);
-
+CLUTTER_AVAILABLE_IN_ALL
 gint                    clutter_event_get_device_id             (const ClutterEvent     *event);
+CLUTTER_AVAILABLE_IN_1_0
 ClutterInputDeviceType  clutter_event_get_device_type           (const ClutterEvent     *event);
-
+CLUTTER_AVAILABLE_IN_1_8
 void                    clutter_event_set_coords                (ClutterEvent           *event,
                                                                  gfloat                  x,
                                                                  gfloat                  y);
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_event_get_coords                (const ClutterEvent     *event,
                                                                  gfloat                 *x,
                                                                  gfloat                 *y);
@@ -491,38 +516,46 @@ float                   clutter_event_get_distance              (const ClutterEv
 CLUTTER_AVAILABLE_IN_1_12
 double                  clutter_event_get_angle                 (const ClutterEvent     *source,
                                                                  const ClutterEvent     *target);
-
+CLUTTER_AVAILABLE_IN_1_6
 gdouble *               clutter_event_get_axes                  (const ClutterEvent     *event,
                                                                  guint                  *n_axes);
-
 CLUTTER_AVAILABLE_IN_1_12
 gboolean                clutter_event_has_shift_modifier        (const ClutterEvent     *event);
 CLUTTER_AVAILABLE_IN_1_12
 gboolean                clutter_event_has_control_modifier      (const ClutterEvent     *event);
 CLUTTER_AVAILABLE_IN_1_12
 gboolean                clutter_event_is_pointer_emulated       (const ClutterEvent     *event);
-
+CLUTTER_AVAILABLE_IN_1_8
 void                    clutter_event_set_key_symbol            (ClutterEvent           *event,
                                                                  guint                   key_sym);
+CLUTTER_AVAILABLE_IN_1_0
 guint                   clutter_event_get_key_symbol            (const ClutterEvent     *event);
+CLUTTER_AVAILABLE_IN_1_8
 void                    clutter_event_set_key_code              (ClutterEvent           *event,
                                                                  guint16                 key_code);
+CLUTTER_AVAILABLE_IN_1_0
 guint16                 clutter_event_get_key_code              (const ClutterEvent     *event);
+CLUTTER_AVAILABLE_IN_1_8
 void                    clutter_event_set_key_unicode           (ClutterEvent           *event,
                                                                  gunichar                key_unicode);
+CLUTTER_AVAILABLE_IN_1_0
 gunichar                clutter_event_get_key_unicode           (const ClutterEvent     *event);
-
+CLUTTER_AVAILABLE_IN_1_8
 void                    clutter_event_set_button                (ClutterEvent           *event,
                                                                  guint32                 button);
+CLUTTER_AVAILABLE_IN_1_0
 guint32                 clutter_event_get_button                (const ClutterEvent     *event);
+CLUTTER_AVAILABLE_IN_1_0
 guint                   clutter_event_get_click_count           (const ClutterEvent     *event);
-
+CLUTTER_AVAILABLE_IN_1_8
 void                    clutter_event_set_related               (ClutterEvent           *event,
                                                                  ClutterActor           *actor);
+CLUTTER_AVAILABLE_IN_1_0
 ClutterActor *          clutter_event_get_related               (const ClutterEvent     *event);
-
+CLUTTER_AVAILABLE_IN_1_8
 void                    clutter_event_set_scroll_direction      (ClutterEvent           *event,
                                                                  ClutterScrollDirection  direction);
+CLUTTER_AVAILABLE_IN_1_0
 ClutterScrollDirection  clutter_event_get_scroll_direction      (const ClutterEvent     *event);
 CLUTTER_AVAILABLE_IN_1_10
 void                    clutter_event_set_scroll_delta          (ClutterEvent           *event,
@@ -536,11 +569,14 @@ void                    clutter_event_get_scroll_delta          (const ClutterEv
 CLUTTER_AVAILABLE_IN_1_10
 ClutterEventSequence *  clutter_event_get_event_sequence        (const ClutterEvent     *event);
 
+CLUTTER_AVAILABLE_IN_ALL
 guint32                 clutter_keysym_to_unicode               (guint                   keyval);
 CLUTTER_AVAILABLE_IN_1_10
 guint                   clutter_unicode_to_keysym               (guint32                 wc);
 
+CLUTTER_AVAILABLE_IN_1_0
 guint32                 clutter_get_current_event_time          (void);
+CLUTTER_AVAILABLE_IN_1_2
 const ClutterEvent *    clutter_get_current_event               (void);
 
 G_END_DECLS
diff --git a/clutter/clutter-feature.h b/clutter/clutter-feature.h
index 4242ce0..083f1a9 100644
--- a/clutter/clutter-feature.h
+++ b/clutter/clutter-feature.h
@@ -32,7 +32,9 @@
 
 G_BEGIN_DECLS
 
+CLUTTER_AVAILABLE_IN_ALL
 gboolean            clutter_feature_available       (ClutterFeatureFlags feature);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterFeatureFlags clutter_feature_get_all         (void);
 
 G_END_DECLS
diff --git a/clutter/clutter-fixed-layout.h b/clutter/clutter-fixed-layout.h
index 32273bc..a64d900 100644
--- a/clutter/clutter-fixed-layout.h
+++ b/clutter/clutter-fixed-layout.h
@@ -71,8 +71,10 @@ struct _ClutterFixedLayoutClass
   ClutterLayoutManagerClass parent_class;
 };
 
+CLUTTER_AVAILABLE_IN_1_2
 GType clutter_fixed_layout_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_2
 ClutterLayoutManager *clutter_fixed_layout_new (void);
 
 G_END_DECLS
diff --git a/clutter/clutter-flow-layout.h b/clutter/clutter-flow-layout.h
index 2acacdd..f552c54 100644
--- a/clutter/clutter-flow-layout.h
+++ b/clutter/clutter-flow-layout.h
@@ -74,33 +74,47 @@ struct _ClutterFlowLayoutClass
   ClutterLayoutManagerClass parent_class;
 };
 
+CLUTTER_AVAILABLE_IN_1_2
 GType clutter_flow_layout_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_2
 ClutterLayoutManager * clutter_flow_layout_new                (ClutterFlowOrientation  orientation);
 
+CLUTTER_AVAILABLE_IN_1_2
 void                   clutter_flow_layout_set_orientation    (ClutterFlowLayout      *layout,
                                                                ClutterFlowOrientation  orientation);
+CLUTTER_AVAILABLE_IN_1_2
 ClutterFlowOrientation clutter_flow_layout_get_orientation    (ClutterFlowLayout      *layout);
+CLUTTER_AVAILABLE_IN_1_2
 void                   clutter_flow_layout_set_homogeneous    (ClutterFlowLayout      *layout,
                                                                gboolean                homogeneous);
+CLUTTER_AVAILABLE_IN_1_2
 gboolean               clutter_flow_layout_get_homogeneous    (ClutterFlowLayout      *layout);
 
+CLUTTER_AVAILABLE_IN_1_2
 void                   clutter_flow_layout_set_column_spacing (ClutterFlowLayout      *layout,
                                                                gfloat                  spacing);
+CLUTTER_AVAILABLE_IN_1_2
 gfloat                 clutter_flow_layout_get_column_spacing (ClutterFlowLayout      *layout);
+CLUTTER_AVAILABLE_IN_1_2
 void                   clutter_flow_layout_set_row_spacing    (ClutterFlowLayout      *layout,
                                                                gfloat                  spacing);
+CLUTTER_AVAILABLE_IN_1_2
 gfloat                 clutter_flow_layout_get_row_spacing    (ClutterFlowLayout      *layout);
 
+CLUTTER_AVAILABLE_IN_1_2
 void                   clutter_flow_layout_set_column_width   (ClutterFlowLayout      *layout,
                                                                gfloat                  min_width,
                                                                gfloat                  max_width);
+CLUTTER_AVAILABLE_IN_1_2
 void                   clutter_flow_layout_get_column_width   (ClutterFlowLayout      *layout,
                                                                gfloat                 *min_width,
                                                                gfloat                 *max_width);
+CLUTTER_AVAILABLE_IN_1_2
 void                   clutter_flow_layout_set_row_height     (ClutterFlowLayout      *layout,
                                                                gfloat                  min_height,
                                                                gfloat                  max_height);
+CLUTTER_AVAILABLE_IN_1_2
 void                   clutter_flow_layout_get_row_height     (ClutterFlowLayout      *layout,
                                                                gfloat                 *min_height,
                                                                gfloat                 *max_height);
diff --git a/clutter/clutter-gesture-action.h b/clutter/clutter-gesture-action.h
index 3f4691e..bb6eac8 100644
--- a/clutter/clutter-gesture-action.h
+++ b/clutter/clutter-gesture-action.h
@@ -101,17 +101,23 @@ struct _ClutterGestureActionClass
   void (* _clutter_gesture_action6) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_8
 GType clutter_gesture_action_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_8
 ClutterAction *        clutter_gesture_action_new                      (void);
 
+CLUTTER_AVAILABLE_IN_1_8
 gint                   clutter_gesture_action_get_n_touch_points   (ClutterGestureAction *action);
+CLUTTER_AVAILABLE_IN_1_8
 void                   clutter_gesture_action_set_n_touch_points   (ClutterGestureAction *action,
                                                                     gint                  nb_points);
+CLUTTER_AVAILABLE_IN_1_8
 void                   clutter_gesture_action_get_press_coords     (ClutterGestureAction *action,
                                                                     guint                 point,
                                                                     gfloat               *press_x,
                                                                     gfloat               *press_y);
+CLUTTER_AVAILABLE_IN_1_8
 void                   clutter_gesture_action_get_motion_coords    (ClutterGestureAction *action,
                                                                     guint                 point,
                                                                     gfloat               *motion_x,
@@ -121,6 +127,7 @@ gfloat                 clutter_gesture_action_get_motion_delta     (ClutterGestu
                                                                     guint                 point,
                                                                     gfloat               *delta_x,
                                                                     gfloat               *delta_y);
+CLUTTER_AVAILABLE_IN_1_8
 void                   clutter_gesture_action_get_release_coords   (ClutterGestureAction *action,
                                                                     guint                 point,
                                                                     gfloat               *release_x,
diff --git a/clutter/clutter-group.h b/clutter/clutter-group.h
index 31f8c03..20afe57 100644
--- a/clutter/clutter-group.h
+++ b/clutter/clutter-group.h
@@ -88,6 +88,7 @@ struct _ClutterGroupClass
   void (*_clutter_reserved6) (void);
 };
 
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_group_get_type (void) G_GNUC_CONST;
 
 G_END_DECLS
diff --git a/clutter/clutter-input-device.h b/clutter/clutter-input-device.h
index 40edadf..4fcdfc7 100644
--- a/clutter/clutter-input-device.h
+++ b/clutter/clutter-input-device.h
@@ -47,9 +47,12 @@ G_BEGIN_DECLS
  */
 typedef struct _ClutterInputDeviceClass ClutterInputDeviceClass;
 
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_input_device_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_0
 ClutterInputDeviceType  clutter_input_device_get_device_type    (ClutterInputDevice  *device);
+CLUTTER_AVAILABLE_IN_1_0
 gint                    clutter_input_device_get_device_id      (ClutterInputDevice  *device);
 
 CLUTTER_AVAILABLE_IN_1_12
@@ -58,36 +61,52 @@ gboolean                clutter_input_device_get_coords        (ClutterInputDevi
                                                                 ClutterPoint         *point);
 CLUTTER_AVAILABLE_IN_1_16
 ClutterModifierType     clutter_input_device_get_modifier_state (ClutterInputDevice  *device);
+CLUTTER_AVAILABLE_IN_1_2
 ClutterActor *          clutter_input_device_get_pointer_actor  (ClutterInputDevice  *device);
+CLUTTER_AVAILABLE_IN_1_2
 ClutterStage *          clutter_input_device_get_pointer_stage  (ClutterInputDevice  *device);
+CLUTTER_AVAILABLE_IN_1_2
 const gchar *           clutter_input_device_get_device_name    (ClutterInputDevice  *device);
+CLUTTER_AVAILABLE_IN_1_2
 ClutterInputMode        clutter_input_device_get_device_mode    (ClutterInputDevice  *device);
+CLUTTER_AVAILABLE_IN_1_2
 gboolean                clutter_input_device_get_has_cursor     (ClutterInputDevice  *device);
+CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_input_device_set_enabled        (ClutterInputDevice  *device,
                                                                  gboolean             enabled);
+CLUTTER_AVAILABLE_IN_1_2
 gboolean                clutter_input_device_get_enabled        (ClutterInputDevice  *device);
 
+CLUTTER_AVAILABLE_IN_1_2
 guint                   clutter_input_device_get_n_axes         (ClutterInputDevice  *device);
+CLUTTER_AVAILABLE_IN_1_2
 ClutterInputAxis        clutter_input_device_get_axis           (ClutterInputDevice  *device,
                                                                  guint                index_);
+CLUTTER_AVAILABLE_IN_1_2
 gboolean                clutter_input_device_get_axis_value     (ClutterInputDevice  *device,
                                                                  gdouble             *axes,
                                                                  ClutterInputAxis     axis,
                                                                  gdouble             *value);
 
+CLUTTER_AVAILABLE_IN_1_2
 guint                   clutter_input_device_get_n_keys         (ClutterInputDevice  *device);
+CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_input_device_set_key            (ClutterInputDevice  *device,
                                                                  guint                index_,
                                                                  guint                keyval,
                                                                  ClutterModifierType  modifiers);
+CLUTTER_AVAILABLE_IN_1_2
 gboolean                clutter_input_device_get_key            (ClutterInputDevice  *device,
                                                                  guint                index_,
                                                                  guint               *keyval,
                                                                  ClutterModifierType *modifiers);
 
+CLUTTER_AVAILABLE_IN_1_2
 ClutterInputDevice *    clutter_input_device_get_associated_device (ClutterInputDevice *device);
+CLUTTER_AVAILABLE_IN_1_2
 GList *                 clutter_input_device_get_slave_devices  (ClutterInputDevice  *device);
 
+CLUTTER_AVAILABLE_IN_1_2
 void                    clutter_input_device_update_from_event  (ClutterInputDevice  *device,
                                                                  ClutterEvent        *event,
                                                                  gboolean             update_stage);
@@ -111,6 +130,7 @@ CLUTTER_AVAILABLE_IN_1_12
 ClutterActor *          clutter_input_device_sequence_get_grabbed_actor (ClutterInputDevice   *device,
                                                                          ClutterEventSequence *sequence);
 
+CLUTTER_AVAILABLE_IN_1_10
 gboolean                clutter_input_device_keycode_to_evdev   (ClutterInputDevice *device,
                                                                  guint               hardware_keycode,
                                                                  guint              *evdev_keycode);
diff --git a/clutter/clutter-interval.c b/clutter/clutter-interval.c
index 033f937..ee8d413 100644
--- a/clutter/clutter-interval.c
+++ b/clutter/clutter-interval.c
@@ -46,9 +46,7 @@
  * #ClutterInterval is available since Clutter 1.0
  */
 
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
 #include <stdlib.h>
 #include <string.h>
@@ -64,6 +62,7 @@
 #include "clutter-scriptable.h"
 #include "clutter-script-private.h"
 
+#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
 #include "deprecated/clutter-fixed.h"
 
 enum
@@ -104,12 +103,15 @@ G_DEFINE_TYPE_WITH_CODE (ClutterInterval,
                          G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_SCRIPTABLE,
                                                 clutter_scriptable_iface_init));
 
+
 static gboolean
 clutter_interval_real_validate (ClutterInterval *interval,
                                 GParamSpec      *pspec)
 {
   GType pspec_gtype = G_PARAM_SPEC_VALUE_TYPE (pspec);
 
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
+
   /* check the GTypes we provide first */
   if (pspec_gtype == COGL_TYPE_FIXED)
     {
@@ -125,6 +127,8 @@ clutter_interval_real_validate (ClutterInterval *interval,
         return FALSE;
     }
 
+G_GNUC_END_IGNORE_DEPRECATIONS;
+
   /* then check the fundamental types */
   switch (G_TYPE_FUNDAMENTAL (pspec_gtype))
     {
diff --git a/clutter/clutter-interval.h b/clutter/clutter-interval.h
index b0c3714..fa36698 100644
--- a/clutter/clutter-interval.h
+++ b/clutter/clutter-interval.h
@@ -92,44 +92,62 @@ struct _ClutterIntervalClass
   void (*_clutter_reserved6) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_0
 GType            clutter_interval_get_type           (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_0
 ClutterInterval *clutter_interval_new                (GType            gtype,
                                                       ...);
+CLUTTER_AVAILABLE_IN_1_0
 ClutterInterval *clutter_interval_new_with_values    (GType            gtype,
                                                       const GValue    *initial,
                                                       const GValue    *final);
 
+CLUTTER_AVAILABLE_IN_1_0
 ClutterInterval *clutter_interval_clone              (ClutterInterval *interval);
 
+CLUTTER_AVAILABLE_IN_1_0
 GType            clutter_interval_get_value_type     (ClutterInterval *interval);
 
+CLUTTER_AVAILABLE_IN_1_10
 void             clutter_interval_set_initial        (ClutterInterval *interval,
                                                       ...);
+CLUTTER_AVAILABLE_IN_1_0
 void             clutter_interval_set_initial_value  (ClutterInterval *interval,
                                                       const GValue    *value);
+CLUTTER_AVAILABLE_IN_1_0
 void             clutter_interval_get_initial_value  (ClutterInterval *interval,
                                                       GValue          *value);
+CLUTTER_AVAILABLE_IN_1_0
 GValue *         clutter_interval_peek_initial_value (ClutterInterval *interval);
+CLUTTER_AVAILABLE_IN_1_10
 void             clutter_interval_set_final          (ClutterInterval *interval,
                                                       ...);
+CLUTTER_AVAILABLE_IN_1_0
 void             clutter_interval_set_final_value    (ClutterInterval *interval,
                                                       const GValue    *value);
+CLUTTER_AVAILABLE_IN_1_0
 void             clutter_interval_get_final_value    (ClutterInterval *interval,
                                                       GValue          *value);
+CLUTTER_AVAILABLE_IN_1_0
 GValue *         clutter_interval_peek_final_value   (ClutterInterval *interval);
 
+CLUTTER_AVAILABLE_IN_1_0
 void             clutter_interval_set_interval       (ClutterInterval *interval,
                                                       ...);
+CLUTTER_AVAILABLE_IN_1_0
 void             clutter_interval_get_interval       (ClutterInterval *interval,
                                                       ...);
 
+CLUTTER_AVAILABLE_IN_1_0
 gboolean         clutter_interval_validate           (ClutterInterval *interval,
                                                       GParamSpec      *pspec);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean         clutter_interval_compute_value      (ClutterInterval *interval,
                                                       gdouble          factor,
                                                       GValue          *value);
 
+CLUTTER_AVAILABLE_IN_1_4
 const GValue *   clutter_interval_compute            (ClutterInterval *interval,
                                                       gdouble          factor);
 
diff --git a/clutter/clutter-layout-manager.h b/clutter/clutter-layout-manager.h
index d054bfd..cbfac1e 100644
--- a/clutter/clutter-layout-manager.h
+++ b/clutter/clutter-layout-manager.h
@@ -149,51 +149,64 @@ struct _ClutterLayoutManagerClass
   void (* _clutter_padding_8) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_2
 GType clutter_layout_manager_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_2
 void               clutter_layout_manager_get_preferred_width   (ClutterLayoutManager   *manager,
                                                                  ClutterContainer       *container,
                                                                  gfloat                  for_height,
                                                                  gfloat                 *min_width_p,
                                                                  gfloat                 *nat_width_p);
+CLUTTER_AVAILABLE_IN_1_2
 void               clutter_layout_manager_get_preferred_height  (ClutterLayoutManager   *manager,
                                                                  ClutterContainer       *container,
                                                                  gfloat                  for_width,
                                                                  gfloat                 *min_height_p,
                                                                  gfloat                 *nat_height_p);
+CLUTTER_AVAILABLE_IN_1_2
 void               clutter_layout_manager_allocate              (ClutterLayoutManager   *manager,
                                                                  ClutterContainer       *container,
                                                                  const ClutterActorBox  *allocation,
                                                                  ClutterAllocationFlags  flags);
 
+CLUTTER_AVAILABLE_IN_1_2
 void               clutter_layout_manager_set_container         (ClutterLayoutManager   *manager,
                                                                  ClutterContainer       *container);
+CLUTTER_AVAILABLE_IN_1_2
 void               clutter_layout_manager_layout_changed        (ClutterLayoutManager   *manager);
 
+CLUTTER_AVAILABLE_IN_1_2
 GParamSpec *       clutter_layout_manager_find_child_property   (ClutterLayoutManager   *manager,
                                                                  const gchar            *name);
+CLUTTER_AVAILABLE_IN_1_2
 GParamSpec **      clutter_layout_manager_list_child_properties (ClutterLayoutManager   *manager,
                                                                  guint                  *n_pspecs);
 
+CLUTTER_AVAILABLE_IN_1_2
 ClutterLayoutMeta *clutter_layout_manager_get_child_meta        (ClutterLayoutManager   *manager,
                                                                  ClutterContainer       *container,
                                                                  ClutterActor           *actor);
 
+CLUTTER_AVAILABLE_IN_1_2
 void               clutter_layout_manager_child_set             (ClutterLayoutManager   *manager,
                                                                  ClutterContainer       *container,
                                                                  ClutterActor           *actor,
                                                                  const gchar            *first_property,
                                                                  ...) G_GNUC_NULL_TERMINATED;
+CLUTTER_AVAILABLE_IN_1_2
 void               clutter_layout_manager_child_get             (ClutterLayoutManager   *manager,
                                                                  ClutterContainer       *container,
                                                                  ClutterActor           *actor,
                                                                  const gchar            *first_property,
                                                                  ...) G_GNUC_NULL_TERMINATED;
+CLUTTER_AVAILABLE_IN_1_2
 void               clutter_layout_manager_child_set_property    (ClutterLayoutManager   *manager,
                                                                  ClutterContainer       *container,
                                                                  ClutterActor           *actor,
                                                                  const gchar            *property_name,
                                                                  const GValue           *value);
+CLUTTER_AVAILABLE_IN_1_2
 void               clutter_layout_manager_child_get_property    (ClutterLayoutManager   *manager,
                                                                  ClutterContainer       *container,
                                                                  ClutterActor           *actor,
diff --git a/clutter/clutter-layout-meta.h b/clutter/clutter-layout-meta.h
index 0f7e7e8..88ab970 100644
--- a/clutter/clutter-layout-meta.h
+++ b/clutter/clutter-layout-meta.h
@@ -92,8 +92,10 @@ struct _ClutterLayoutMetaClass
   void (*_clutter_padding4) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_2
 GType clutter_layout_meta_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_2
 ClutterLayoutManager *clutter_layout_meta_get_manager (ClutterLayoutMeta *data);
 
 G_END_DECLS
diff --git a/clutter/clutter-list-model.h b/clutter/clutter-list-model.h
index e84cef5..ed52823 100644
--- a/clutter/clutter-list-model.h
+++ b/clutter/clutter-list-model.h
@@ -75,10 +75,13 @@ struct _ClutterListModelClass
   ClutterModelClass parent_class;
 };
 
+CLUTTER_AVAILABLE_IN_ALL
 GType         clutter_list_model_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_ALL
 ClutterModel *clutter_list_model_new      (guint                n_columns,
                                               ...);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterModel *clutter_list_model_newv     (guint                n_columns,
                                            GType               *types,
                                            const gchar * const  names[]);
diff --git a/clutter/clutter-macros.h b/clutter/clutter-macros.h
index 20c4478..85bde49 100644
--- a/clutter/clutter-macros.h
+++ b/clutter/clutter-macros.h
@@ -92,6 +92,10 @@
 #define CLUTTER_PRIVATE_FIELD(x)        clutter_private_ ## x
 #endif
 
+#ifndef _CLUTTER_EXTERN
+#define _CLUTTER_EXTERN extern
+#endif
+
 /* these macros are used to mark deprecated functions, and thus have to be
  * exposed in a public header.
  *
@@ -99,15 +103,17 @@
  * and G_DEPRECATED_FOR, or use your own wrappers around them.
  */
 #ifdef CLUTTER_DISABLE_DEPRECATION_WARNINGS
-#define CLUTTER_DEPRECATED
-#define CLUTTER_DEPRECATED_FOR(f)
-#define CLUTTER_UNAVAILABLE(maj,min)
+#define CLUTTER_DEPRECATED _CLUTTER_EXTERN
+#define CLUTTER_DEPRECATED_FOR(f) _CLUTTER_EXTERN
+#define CLUTTER_UNAVAILABLE(maj,min) _CLUTTER_EXTERN
 #else
-#define CLUTTER_DEPRECATED G_DEPRECATED
-#define CLUTTER_DEPRECATED_FOR(f) G_DEPRECATED_FOR(f)
-#define CLUTTER_UNAVAILABLE(maj,min) G_UNAVAILABLE(maj,min)
+#define CLUTTER_DEPRECATED G_DEPRECATED _CLUTTER_EXTERN
+#define CLUTTER_DEPRECATED_FOR(f) G_DEPRECATED_FOR(f) _CLUTTER_EXTERN
+#define CLUTTER_UNAVAILABLE(maj,min) G_UNAVAILABLE(maj,min) _CLUTTER_EXTERN
 #endif
 
+#define CLUTTER_AVAILABLE_IN_ALL _CLUTTER_EXTERN
+
 /**
  * CLUTTER_VERSION_MIN_REQUIRED:
  *
@@ -168,140 +174,140 @@
 # define CLUTTER_DEPRECATED_IN_1_0              CLUTTER_DEPRECATED
 # define CLUTTER_DEPRECATED_IN_1_0_FOR(f)       CLUTTER_DEPRECATED_FOR(f)
 #else
-# define CLUTTER_DEPRECATED_IN_1_0
-# define CLUTTER_DEPRECATED_IN_1_0_FOR(f)
+# define CLUTTER_DEPRECATED_IN_1_0              _CLUTTER_EXTERN
+# define CLUTTER_DEPRECATED_IN_1_0_FOR(f)       _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MAX_ALLOWED < CLUTTER_VERSION_1_0
 # define CLUTTER_AVAILABLE_IN_1_0               CLUTTER_UNAVAILABLE(1, 0)
 #else
-# define CLUTTER_AVAILABLE_IN_1_0
+# define CLUTTER_AVAILABLE_IN_1_0               _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MIN_REQUIRED >= CLUTTER_VERSION_1_2
 # define CLUTTER_DEPRECATED_IN_1_2              CLUTTER_DEPRECATED
 # define CLUTTER_DEPRECATED_IN_1_2_FOR(f)       CLUTTER_DEPRECATED_FOR(f)
 #else
-# define CLUTTER_DEPRECATED_IN_1_2
-# define CLUTTER_DEPRECATED_IN_1_2_FOR(f)
+# define CLUTTER_DEPRECATED_IN_1_2              _CLUTTER_EXTERN
+# define CLUTTER_DEPRECATED_IN_1_2_FOR(f)       _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MAX_ALLOWED < CLUTTER_VERSION_1_2
 # define CLUTTER_AVAILABLE_IN_1_2               CLUTTER_UNAVAILABLE(1, 2)
 #else
-# define CLUTTER_AVAILABLE_IN_1_2
+# define CLUTTER_AVAILABLE_IN_1_2               _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MIN_REQUIRED >= CLUTTER_VERSION_1_4
 # define CLUTTER_DEPRECATED_IN_1_4              CLUTTER_DEPRECATED
 # define CLUTTER_DEPRECATED_IN_1_4_FOR(f)       CLUTTER_DEPRECATED_FOR(f)
 #else
-# define CLUTTER_DEPRECATED_IN_1_4
-# define CLUTTER_DEPRECATED_IN_1_4_FOR(f)
+# define CLUTTER_DEPRECATED_IN_1_4              _CLUTTER_EXTERN
+# define CLUTTER_DEPRECATED_IN_1_4_FOR(f)       _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MAX_ALLOWED < CLUTTER_VERSION_1_4
 # define CLUTTER_AVAILABLE_IN_1_4               CLUTTER_UNAVAILABLE(1, 4)
 #else
-# define CLUTTER_AVAILABLE_IN_1_4
+# define CLUTTER_AVAILABLE_IN_1_4               _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MIN_REQUIRED >= CLUTTER_VERSION_1_6
 # define CLUTTER_DEPRECATED_IN_1_6              CLUTTER_DEPRECATED
 # define CLUTTER_DEPRECATED_IN_1_6_FOR(f)       CLUTTER_DEPRECATED_FOR(f)
 #else
-# define CLUTTER_DEPRECATED_IN_1_6
-# define CLUTTER_DEPRECATED_IN_1_6_FOR(f)
+# define CLUTTER_DEPRECATED_IN_1_6              _CLUTTER_EXTERN
+# define CLUTTER_DEPRECATED_IN_1_6_FOR(f)       _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MAX_ALLOWED < CLUTTER_VERSION_1_6
 # define CLUTTER_AVAILABLE_IN_1_6               CLUTTER_UNAVAILABLE(1, 6)
 #else
-# define CLUTTER_AVAILABLE_IN_1_6
+# define CLUTTER_AVAILABLE_IN_1_6               _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MIN_REQUIRED >= CLUTTER_VERSION_1_8
 # define CLUTTER_DEPRECATED_IN_1_8              CLUTTER_DEPRECATED
 # define CLUTTER_DEPRECATED_IN_1_8_FOR(f)       CLUTTER_DEPRECATED_FOR(f)
 #else
-# define CLUTTER_DEPRECATED_IN_1_8
-# define CLUTTER_DEPRECATED_IN_1_8_FOR(f)
+# define CLUTTER_DEPRECATED_IN_1_8              _CLUTTER_EXTERN
+# define CLUTTER_DEPRECATED_IN_1_8_FOR(f)       _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MAX_ALLOWED < CLUTTER_VERSION_1_8
 # define CLUTTER_AVAILABLE_IN_1_8               CLUTTER_UNAVAILABLE(1, 8)
 #else
-# define CLUTTER_AVAILABLE_IN_1_8
+# define CLUTTER_AVAILABLE_IN_1_8               _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MIN_REQUIRED >= CLUTTER_VERSION_1_10
 # define CLUTTER_DEPRECATED_IN_1_10             CLUTTER_DEPRECATED
 # define CLUTTER_DEPRECATED_IN_1_10_FOR(f)      CLUTTER_DEPRECATED_FOR(f)
 #else
-# define CLUTTER_DEPRECATED_IN_1_10
-# define CLUTTER_DEPRECATED_IN_1_10_FOR(f)
+# define CLUTTER_DEPRECATED_IN_1_10             _CLUTTER_EXTERN
+# define CLUTTER_DEPRECATED_IN_1_10_FOR(f)      _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MAX_ALLOWED < CLUTTER_VERSION_1_10
 # define CLUTTER_AVAILABLE_IN_1_10              CLUTTER_UNAVAILABLE(1, 10)
 #else
-# define CLUTTER_AVAILABLE_IN_1_10
+# define CLUTTER_AVAILABLE_IN_1_10              _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MIN_REQUIRED >= CLUTTER_VERSION_1_12
 # define CLUTTER_DEPRECATED_IN_1_12             CLUTTER_DEPRECATED
 # define CLUTTER_DEPRECATED_IN_1_12_FOR(f)      CLUTTER_DEPRECATED_FOR(f)
 #else
-# define CLUTTER_DEPRECATED_IN_1_12
-# define CLUTTER_DEPRECATED_IN_1_12_FOR(f)
+# define CLUTTER_DEPRECATED_IN_1_12             _CLUTTER_EXTERN
+# define CLUTTER_DEPRECATED_IN_1_12_FOR(f)      _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MAX_ALLOWED < CLUTTER_VERSION_1_12
 # define CLUTTER_AVAILABLE_IN_1_12              CLUTTER_UNAVAILABLE(1, 12)
 #else
-# define CLUTTER_AVAILABLE_IN_1_12
+# define CLUTTER_AVAILABLE_IN_1_12              _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MIN_REQUIRED >= CLUTTER_VERSION_1_14
 # define CLUTTER_DEPRECATED_IN_1_14             CLUTTER_DEPRECATED
 # define CLUTTER_DEPRECATED_IN_1_14_FOR(f)      CLUTTER_DEPRECATED_FOR(f)
 #else
-# define CLUTTER_DEPRECATED_IN_1_14
-# define CLUTTER_DEPRECATED_IN_1_14_FOR(f)
+# define CLUTTER_DEPRECATED_IN_1_14             _CLUTTER_EXTERN
+# define CLUTTER_DEPRECATED_IN_1_14_FOR(f)      _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MAX_ALLOWED < CLUTTER_VERSION_1_14
 # define CLUTTER_AVAILABLE_IN_1_14              CLUTTER_UNAVAILABLE(1, 14)
 #else
-# define CLUTTER_AVAILABLE_IN_1_14
+# define CLUTTER_AVAILABLE_IN_1_14              _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MIN_REQUIRED >= CLUTTER_VERSION_1_16
 # define CLUTTER_DEPRECATED_IN_1_16             CLUTTER_DEPRECATED
 # define CLUTTER_DEPRECATED_IN_1_16_FOR(f)      CLUTTER_DEPRECATED_FOR(f)
 #else
-# define CLUTTER_DEPRECATED_IN_1_16
-# define CLUTTER_DEPRECATED_IN_1_16_FOR(f)
+# define CLUTTER_DEPRECATED_IN_1_16             _CLUTTER_EXTERN
+# define CLUTTER_DEPRECATED_IN_1_16_FOR(f)      _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MAX_ALLOWED < CLUTTER_VERSION_1_16
 # define CLUTTER_AVAILABLE_IN_1_16              CLUTTER_UNAVAILABLE(1, 16)
 #else
-# define CLUTTER_AVAILABLE_IN_1_16
+# define CLUTTER_AVAILABLE_IN_1_16              _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MIN_REQUIRED >= CLUTTER_VERSION_1_18
 # define CLUTTER_DEPRECATED_IN_1_18             CLUTTER_DEPRECATED
 # define CLUTTER_DEPRECATED_IN_1_18_FOR(f)      CLUTTER_DEPRECATED_FOR(f)
 #else
-# define CLUTTER_DEPRECATED_IN_1_18
-# define CLUTTER_DEPRECATED_IN_1_18_FOR(f)
+# define CLUTTER_DEPRECATED_IN_1_18             _CLUTTER_EXTERN
+# define CLUTTER_DEPRECATED_IN_1_18_FOR(f)      _CLUTTER_EXTERN
 #endif
 
 #if CLUTTER_VERSION_MAX_ALLOWED < CLUTTER_VERSION_1_18
 # define CLUTTER_AVAILABLE_IN_1_18              CLUTTER_UNAVAILABLE(1, 18)
 #else
-# define CLUTTER_AVAILABLE_IN_1_18
+# define CLUTTER_AVAILABLE_IN_1_18              _CLUTTER_EXTERN
 #endif
 
 #endif /* __CLUTTER_MACROS_H__ */
diff --git a/clutter/clutter-main.h b/clutter/clutter-main.h
index b7c8565..c7f2460 100644
--- a/clutter/clutter-main.h
+++ b/clutter/clutter-main.h
@@ -61,6 +61,7 @@ typedef enum {
   CLUTTER_INIT_ERROR_INTERNAL = -3
 } ClutterInitError;
 
+CLUTTER_AVAILABLE_IN_ALL
 GQuark clutter_init_error_quark (void);
 
 /**
@@ -77,9 +78,12 @@ GQuark clutter_init_error_quark (void);
 #define CLUTTER_PRIORITY_REDRAW         (G_PRIORITY_HIGH_IDLE + 50)
 
 /* Initialisation */
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_base_init                       (void);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterInitError        clutter_init                            (int          *argc,
                                                                  char       ***argv) 
G_GNUC_WARN_UNUSED_RESULT;
+CLUTTER_AVAILABLE_IN_ALL
 ClutterInitError        clutter_init_with_args                  (int          *argc,
                                                                  char       ***argv,
                                                                  const char   *parameter_string,
@@ -87,39 +91,52 @@ ClutterInitError        clutter_init_with_args                  (int          *a
                                                                  const char   *translation_domain,
                                                                  GError      **error) 
G_GNUC_WARN_UNUSED_RESULT;
 
+CLUTTER_AVAILABLE_IN_ALL
 GOptionGroup *          clutter_get_option_group                (void);
+CLUTTER_AVAILABLE_IN_ALL
 GOptionGroup *          clutter_get_option_group_without_init   (void);
 
 /* Mainloop */
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_main                            (void);
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_main_quit                       (void);
+CLUTTER_AVAILABLE_IN_ALL
 gint                    clutter_main_level                      (void);
 
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_do_event                        (ClutterEvent *event);
 
 /* Debug utility functions */
+CLUTTER_AVAILABLE_IN_1_4
 gboolean                clutter_get_accessibility_enabled       (void);
 
 CLUTTER_AVAILABLE_IN_1_14
 void                    clutter_disable_accessibility           (void);
 
 /* Threading functions */
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_threads_set_lock_functions      (GCallback enter_fn,
                                                                  GCallback leave_fn);
+CLUTTER_AVAILABLE_IN_ALL
 guint                   clutter_threads_add_idle                (GSourceFunc    func,
                                                                  gpointer       data);
+CLUTTER_AVAILABLE_IN_ALL
 guint                   clutter_threads_add_idle_full           (gint           priority,
                                                                  GSourceFunc    func,
                                                                  gpointer       data,
                                                                  GDestroyNotify notify);
+CLUTTER_AVAILABLE_IN_ALL
 guint                   clutter_threads_add_timeout             (guint          interval,
                                                                  GSourceFunc    func,
                                                                  gpointer       data);
+CLUTTER_AVAILABLE_IN_ALL
 guint                   clutter_threads_add_timeout_full        (gint           priority,
                                                                  guint          interval,
                                                                  GSourceFunc    func,
                                                                  gpointer       data,
                                                                  GDestroyNotify notify);
+CLUTTER_AVAILABLE_IN_1_0
 guint                   clutter_threads_add_repaint_func        (GSourceFunc    func,
                                                                  gpointer       data,
                                                                  GDestroyNotify notify);
@@ -128,21 +145,40 @@ guint                   clutter_threads_add_repaint_func_full   (ClutterRepaintF
                                                                  GSourceFunc    func,
                                                                  gpointer       data,
                                                                  GDestroyNotify notify);
+CLUTTER_AVAILABLE_IN_1_0
 void                    clutter_threads_remove_repaint_func     (guint          handle_id);
 
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_grab_pointer                    (ClutterActor  *actor);
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_ungrab_pointer                  (void);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor *          clutter_get_pointer_grab                (void);
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_grab_keyboard                   (ClutterActor  *actor);
+CLUTTER_AVAILABLE_IN_ALL
 void                    clutter_ungrab_keyboard                 (void);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor *          clutter_get_keyboard_grab               (void);
 
+CLUTTER_AVAILABLE_IN_ALL
 PangoFontMap *          clutter_get_font_map                    (void);
 
+CLUTTER_AVAILABLE_IN_ALL
 ClutterTextDirection    clutter_get_default_text_direction      (void);
 
+CLUTTER_AVAILABLE_IN_ALL
 guint                   clutter_get_default_frame_rate          (void);
 
+CLUTTER_AVAILABLE_IN_1_2
+gboolean                clutter_check_version                   (guint major,
+                                                                 guint minor,
+                                                                 guint micro);
+
+CLUTTER_AVAILABLE_IN_1_10
+gboolean                clutter_check_windowing_backend         (const char *backend_type);
+
+
 G_END_DECLS
 
 #endif /* _CLUTTER_MAIN_H__ */
diff --git a/clutter/clutter-model.h b/clutter/clutter-model.h
index a8217ba..a2dad66 100644
--- a/clutter/clutter-model.h
+++ b/clutter/clutter-model.h
@@ -30,7 +30,7 @@
 #ifndef __CLUTTER_MODEL_H__
 #define __CLUTTER_MODEL_H__
 
-#include <glib-object.h>
+#include <clutter/clutter-types.h>
 
 G_BEGIN_DECLS
 
@@ -188,75 +188,102 @@ struct _ClutterModelClass
   void (*_clutter_model_8) (void);
 };
 
+CLUTTER_AVAILABLE_IN_ALL
 GType                 clutter_model_get_type           (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_set_types          (ClutterModel     *model,
                                                         guint             n_columns,
                                                         GType            *types);
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_set_names          (ClutterModel     *model,
                                                         guint             n_columns,
                                                         const gchar * const names[]);
 
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_append             (ClutterModel     *model,
                                                         ...);
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_appendv            (ClutterModel     *model,
                                                         guint             n_columns,
                                                         guint            *columns,
                                                         GValue           *values);
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_prepend            (ClutterModel     *model,
                                                         ...);
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_prependv           (ClutterModel     *model,
                                                         guint             n_columns,
                                                         guint            *columns,
                                                         GValue           *values);
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_insert             (ClutterModel     *model,
                                                         guint             row,
                                                         ...);
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_insertv            (ClutterModel     *model,
                                                         guint             row,
                                                         guint             n_columns,
                                                         guint            *columns,
                                                         GValue           *values);
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_insert_value       (ClutterModel     *model,
                                                         guint             row,
                                                         guint             column,
                                                         const GValue     *value);
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_remove             (ClutterModel     *model,
                                                         guint             row);
 
+CLUTTER_AVAILABLE_IN_ALL
 guint                 clutter_model_get_n_rows         (ClutterModel     *model);
+CLUTTER_AVAILABLE_IN_ALL
 guint                 clutter_model_get_n_columns      (ClutterModel     *model);
+CLUTTER_AVAILABLE_IN_ALL
 const gchar *         clutter_model_get_column_name    (ClutterModel     *model,
                                                         guint             column);
+CLUTTER_AVAILABLE_IN_ALL
 GType                 clutter_model_get_column_type    (ClutterModel     *model,
                                                         guint             column);
 
+CLUTTER_AVAILABLE_IN_ALL
 ClutterModelIter *    clutter_model_get_first_iter     (ClutterModel     *model);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterModelIter *    clutter_model_get_last_iter      (ClutterModel     *model);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterModelIter *    clutter_model_get_iter_at_row    (ClutterModel     *model,
                                                         guint             row);
 
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_set_sorting_column (ClutterModel     *model,
                                                         gint              column);
+CLUTTER_AVAILABLE_IN_ALL
 gint                  clutter_model_get_sorting_column (ClutterModel     *model);
 
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_foreach            (ClutterModel     *model,
                                                         ClutterModelForeachFunc func, 
                                                         gpointer          user_data);
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_set_sort           (ClutterModel     *model, 
                                                         gint              column,
                                                         ClutterModelSortFunc func, 
                                                         gpointer          user_data,
                                                         GDestroyNotify    notify);
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_set_filter         (ClutterModel     *model, 
                                                         ClutterModelFilterFunc func, 
                                                         gpointer          user_data,
                                                         GDestroyNotify    notify);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean              clutter_model_get_filter_set     (ClutterModel     *model);
 
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_model_resort             (ClutterModel     *model);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean              clutter_model_filter_row         (ClutterModel     *model,
                                                         guint             row);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean              clutter_model_filter_iter        (ClutterModel     *model,
                                                         ClutterModelIter *iter);
 
@@ -349,31 +376,45 @@ struct _ClutterModelIterClass
   void (*_clutter_model_iter_8) (void);
 };
 
+CLUTTER_AVAILABLE_IN_ALL
 GType             clutter_model_iter_get_type   (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_ALL
 void              clutter_model_iter_get        (ClutterModelIter *iter,
                                                  ...);
+CLUTTER_AVAILABLE_IN_ALL
 void              clutter_model_iter_get_valist (ClutterModelIter *iter,
                                                  va_list          args);
+CLUTTER_AVAILABLE_IN_ALL
 void              clutter_model_iter_get_value  (ClutterModelIter *iter,
                                                  guint             column,
                                                  GValue           *value);
+CLUTTER_AVAILABLE_IN_ALL
 void              clutter_model_iter_set        (ClutterModelIter *iter,
                                                  ...);
+CLUTTER_AVAILABLE_IN_ALL
 void              clutter_model_iter_set_valist (ClutterModelIter *iter,
                                                  va_list          args);
+CLUTTER_AVAILABLE_IN_ALL
 void              clutter_model_iter_set_value  (ClutterModelIter *iter,
                                                  guint             column,
                                                  const GValue     *value);
 
+CLUTTER_AVAILABLE_IN_ALL
 gboolean          clutter_model_iter_is_first   (ClutterModelIter *iter);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean          clutter_model_iter_is_last    (ClutterModelIter *iter);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterModelIter *clutter_model_iter_next       (ClutterModelIter *iter);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterModelIter *clutter_model_iter_prev       (ClutterModelIter *iter);
 
+CLUTTER_AVAILABLE_IN_ALL
 ClutterModel *    clutter_model_iter_get_model  (ClutterModelIter *iter);
+CLUTTER_AVAILABLE_IN_ALL
 guint             clutter_model_iter_get_row    (ClutterModelIter *iter);
 
+CLUTTER_AVAILABLE_IN_ALL
 ClutterModelIter *clutter_model_iter_copy       (ClutterModelIter *iter);
 
 G_END_DECLS
diff --git a/clutter/clutter-offscreen-effect.h b/clutter/clutter-offscreen-effect.h
index 6e70cbe..8fd547e 100644
--- a/clutter/clutter-offscreen-effect.h
+++ b/clutter/clutter-offscreen-effect.h
@@ -92,14 +92,18 @@ struct _ClutterOffscreenEffectClass
   void (* _clutter_offscreen7) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_offscreen_effect_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_4
 CoglMaterial *  clutter_offscreen_effect_get_target             (ClutterOffscreenEffect *effect);
 
 CLUTTER_AVAILABLE_IN_1_10
 CoglHandle      clutter_offscreen_effect_get_texture            (ClutterOffscreenEffect *effect);
 
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_offscreen_effect_paint_target           (ClutterOffscreenEffect *effect);
+CLUTTER_AVAILABLE_IN_1_4
 CoglHandle      clutter_offscreen_effect_create_texture         (ClutterOffscreenEffect *effect,
                                                                  gfloat                  width,
                                                                  gfloat                  height);
diff --git a/clutter/clutter-page-turn-effect.h b/clutter/clutter-page-turn-effect.h
index 9a9b2fe..befdf41 100644
--- a/clutter/clutter-page-turn-effect.h
+++ b/clutter/clutter-page-turn-effect.h
@@ -51,20 +51,28 @@ G_BEGIN_DECLS
 typedef struct _ClutterPageTurnEffect           ClutterPageTurnEffect;
 typedef struct _ClutterPageTurnEffectClass      ClutterPageTurnEffectClass;
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_page_turn_effect_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_4
 ClutterEffect *clutter_page_turn_effect_new (gdouble period,
                                              gdouble angle,
                                              gfloat  radius);
 
+CLUTTER_AVAILABLE_IN_1_4
 void    clutter_page_turn_effect_set_period (ClutterPageTurnEffect *effect,
                                              gdouble                period);
+CLUTTER_AVAILABLE_IN_1_4
 gdouble clutter_page_turn_effect_get_period (ClutterPageTurnEffect *effect);
+CLUTTER_AVAILABLE_IN_1_4
 void    clutter_page_turn_effect_set_angle  (ClutterPageTurnEffect *effect,
                                              gdouble                angle);
+CLUTTER_AVAILABLE_IN_1_4
 gdouble clutter_page_turn_effect_get_angle  (ClutterPageTurnEffect *effect);
+CLUTTER_AVAILABLE_IN_1_4
 void    clutter_page_turn_effect_set_radius (ClutterPageTurnEffect *effect,
                                              gfloat                 radius);
+CLUTTER_AVAILABLE_IN_1_4
 gfloat  clutter_page_turn_effect_get_radius (ClutterPageTurnEffect *effect);
 
 G_END_DECLS
diff --git a/clutter/clutter-path-constraint.h b/clutter/clutter-path-constraint.h
index e65555e..63da495 100644
--- a/clutter/clutter-path-constraint.h
+++ b/clutter/clutter-path-constraint.h
@@ -49,16 +49,22 @@ G_BEGIN_DECLS
 typedef struct _ClutterPathConstraint           ClutterPathConstraint;
 typedef struct _ClutterPathConstraintClass      ClutterPathConstraintClass;
 
+CLUTTER_AVAILABLE_IN_1_6
 GType clutter_path_constraint_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_6
 ClutterConstraint *clutter_path_constraint_new        (ClutterPath           *path,
                                                        gfloat                 offset);
 
+CLUTTER_AVAILABLE_IN_1_6
 void               clutter_path_constraint_set_path   (ClutterPathConstraint *constraint,
                                                        ClutterPath           *path);
+CLUTTER_AVAILABLE_IN_1_6
 ClutterPath *      clutter_path_constraint_get_path   (ClutterPathConstraint *constraint);
+CLUTTER_AVAILABLE_IN_1_6
 void               clutter_path_constraint_set_offset (ClutterPathConstraint *constraint,
                                                        gfloat                 offset);
+CLUTTER_AVAILABLE_IN_1_6
 gfloat             clutter_path_constraint_get_offset (ClutterPathConstraint *constraint);
 
 G_END_DECLS
diff --git a/clutter/clutter-path.h b/clutter/clutter-path.h
index 599499a..c170bb3 100644
--- a/clutter/clutter-path.h
+++ b/clutter/clutter-path.h
@@ -86,22 +86,30 @@ struct _ClutterPathClass
   GInitiallyUnownedClass parent_class;
 };
 
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_path_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_0
 ClutterPath *clutter_path_new                  (void);
+CLUTTER_AVAILABLE_IN_1_0
 ClutterPath *clutter_path_new_with_description (const gchar           *desc);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_add_move_to          (ClutterPath           *path,
                                                 gint                   x,
                                                 gint                   y);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_add_rel_move_to      (ClutterPath           *path,
                                                 gint                   x,
                                                 gint                   y);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_add_line_to          (ClutterPath           *path,
                                                 gint                   x,
                                                 gint                   y);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_add_rel_line_to      (ClutterPath           *path,
                                                 gint                   x,
                                                 gint                   y);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_add_curve_to         (ClutterPath           *path,
                                                 gint                   x_1,
                                                 gint                   y_1,
@@ -109,6 +117,7 @@ void         clutter_path_add_curve_to         (ClutterPath           *path,
                                                 gint                   y_2,
                                                 gint                   x_3,
                                                 gint                   y_3);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_add_rel_curve_to     (ClutterPath           *path,
                                                 gint                   x_1,
                                                 gint                   y_1,
@@ -116,38 +125,55 @@ void         clutter_path_add_rel_curve_to     (ClutterPath           *path,
                                                 gint                   y_2,
                                                 gint                   x_3,
                                                 gint                   y_3);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_add_close            (ClutterPath           *path);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean     clutter_path_add_string           (ClutterPath           *path,
                                                 const gchar           *str);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_add_node             (ClutterPath           *path,
                                                 const ClutterPathNode *node);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_add_cairo_path       (ClutterPath           *path,
                                                 const cairo_path_t    *cpath);
+CLUTTER_AVAILABLE_IN_1_0
 guint        clutter_path_get_n_nodes          (ClutterPath           *path);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_get_node             (ClutterPath           *path,
                                                 guint                  index_,
                                                 ClutterPathNode       *node);
+CLUTTER_AVAILABLE_IN_1_0
 GSList *     clutter_path_get_nodes            (ClutterPath           *path);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_foreach              (ClutterPath           *path,
                                                 ClutterPathCallback    callback,
                                                 gpointer               user_data);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_insert_node          (ClutterPath           *path,
                                                 gint                   index_,
                                                 const ClutterPathNode *node);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_remove_node          (ClutterPath           *path,
                                                 guint                  index_);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_replace_node         (ClutterPath           *path,
                                                 guint                  index_,
                                                 const ClutterPathNode *node);
+CLUTTER_AVAILABLE_IN_1_0
 gchar *      clutter_path_get_description      (ClutterPath           *path);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean     clutter_path_set_description      (ClutterPath           *path,
                                                 const gchar           *str);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_clear                (ClutterPath           *path);
+CLUTTER_AVAILABLE_IN_1_0
 void         clutter_path_to_cairo_path        (ClutterPath           *path,
                                                 cairo_t               *cr);
+CLUTTER_AVAILABLE_IN_1_0
 guint        clutter_path_get_position         (ClutterPath           *path,
                                                 gdouble                progress,
                                                 ClutterKnot           *position);
+CLUTTER_AVAILABLE_IN_1_0
 guint        clutter_path_get_length           (ClutterPath           *path);
 
 G_END_DECLS
diff --git a/clutter/clutter-script.h b/clutter/clutter-script.h
index f2b6222..4ac5c8f 100644
--- a/clutter/clutter-script.h
+++ b/clutter/clutter-script.h
@@ -93,6 +93,7 @@ typedef enum {
  * Since: 0.6
  */
 #define CLUTTER_SCRIPT_ERROR    (clutter_script_error_quark ())
+CLUTTER_AVAILABLE_IN_ALL
 GQuark clutter_script_error_quark (void);
 
 /**
@@ -143,12 +144,16 @@ struct _ClutterScriptClass
   void (*_clutter_reserved8) (void);
 };
 
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_script_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_ALL
 ClutterScript * clutter_script_new                      (void);
+CLUTTER_AVAILABLE_IN_ALL
 guint           clutter_script_load_from_file           (ClutterScript             *script,
                                                          const gchar               *filename,
                                                          GError                   **error);
+CLUTTER_AVAILABLE_IN_ALL
 guint           clutter_script_load_from_data           (ClutterScript             *script,
                                                          const gchar               *data,
                                                          gssize                     length,
@@ -158,14 +163,19 @@ guint           clutter_script_load_from_resource       (ClutterScript
                                                          const gchar               *resource_path,
                                                          GError                   **error);
 
+CLUTTER_AVAILABLE_IN_ALL
 GObject *       clutter_script_get_object               (ClutterScript             *script,
                                                          const gchar               *name);
+CLUTTER_AVAILABLE_IN_ALL
 gint            clutter_script_get_objects              (ClutterScript             *script,
                                                          const gchar               *first_name,
                                                          ...) G_GNUC_NULL_TERMINATED;
+CLUTTER_AVAILABLE_IN_ALL
 GList *         clutter_script_list_objects             (ClutterScript             *script);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_script_unmerge_objects          (ClutterScript             *script,
                                                          guint                      merge_id);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_script_ensure_objects           (ClutterScript             *script);
 
 CLUTTER_DEPRECATED_IN_1_12
@@ -177,17 +187,22 @@ CLUTTER_DEPRECATED_IN_1_12
 ClutterState *  clutter_script_get_states               (ClutterScript             *script,
                                                          const gchar               *name);
 
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_script_connect_signals          (ClutterScript             *script,
                                                          gpointer                   user_data);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_script_connect_signals_full     (ClutterScript             *script,
                                                          ClutterScriptConnectFunc   func,
                                                          gpointer                   user_data);
 
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_script_add_search_paths         (ClutterScript             *script,
                                                          const gchar * const        paths[],
                                                          gsize                      n_paths);
+CLUTTER_AVAILABLE_IN_ALL
 gchar *         clutter_script_lookup_filename          (ClutterScript             *script,
                                                          const gchar               *filename) G_GNUC_MALLOC;
+CLUTTER_AVAILABLE_IN_ALL
 GType           clutter_script_get_type_from_name       (ClutterScript             *script,
                                                          const gchar               *type_name);
 
@@ -197,6 +212,7 @@ void            clutter_script_set_translation_domain   (ClutterScript
 CLUTTER_AVAILABLE_IN_1_10
 const gchar *   clutter_script_get_translation_domain   (ClutterScript             *script);
 
+CLUTTER_AVAILABLE_IN_ALL
 const gchar *   clutter_get_script_id                   (GObject                   *gobject);
 
 G_END_DECLS
diff --git a/clutter/clutter-scriptable.h b/clutter/clutter-scriptable.h
index f47aac4..f66ec86 100644
--- a/clutter/clutter-scriptable.h
+++ b/clutter/clutter-scriptable.h
@@ -87,16 +87,21 @@ struct _ClutterScriptableIface
                                         const GValue      *value);
 };
 
+CLUTTER_AVAILABLE_IN_ALL
 GType                 clutter_scriptable_get_type            (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_scriptable_set_id              (ClutterScriptable *scriptable,
                                                               const gchar       *id_);
+CLUTTER_AVAILABLE_IN_ALL
 const gchar *         clutter_scriptable_get_id              (ClutterScriptable *scriptable);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean              clutter_scriptable_parse_custom_node   (ClutterScriptable *scriptable,
                                                               ClutterScript     *script,
                                                               GValue            *value,
                                                               const gchar       *name,
                                                               JsonNode          *node);
+CLUTTER_AVAILABLE_IN_ALL
 void                  clutter_scriptable_set_custom_property (ClutterScriptable *scriptable,
                                                               ClutterScript     *script,
                                                               const gchar       *name,
diff --git a/clutter/clutter-settings.h b/clutter/clutter-settings.h
index aa254ec..6e5719a 100644
--- a/clutter/clutter-settings.h
+++ b/clutter/clutter-settings.h
@@ -16,8 +16,10 @@ G_BEGIN_DECLS
 typedef struct _ClutterSettings         ClutterSettings;
 typedef struct _ClutterSettingsClass    ClutterSettingsClass;
 
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_settings_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_ALL
 ClutterSettings *clutter_settings_get_default (void);
 
 G_END_DECLS
diff --git a/clutter/clutter-shader-effect.h b/clutter/clutter-shader-effect.h
index 9777b64..1ffc394 100644
--- a/clutter/clutter-shader-effect.h
+++ b/clutter/clutter-shader-effect.h
@@ -90,23 +90,30 @@ struct _ClutterShaderEffectClass
   void (*_clutter_shader5) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_4
 GType clutter_shader_effect_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_4
 ClutterEffect * clutter_shader_effect_new               (ClutterShaderType    shader_type);
 
+CLUTTER_AVAILABLE_IN_1_4
 gboolean        clutter_shader_effect_set_shader_source (ClutterShaderEffect *effect,
                                                          const gchar         *source);
 
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_shader_effect_set_uniform       (ClutterShaderEffect *effect,
                                                          const gchar         *name,
                                                          GType                gtype,
                                                          gsize                n_values,
                                                          ...);
+CLUTTER_AVAILABLE_IN_1_4
 void            clutter_shader_effect_set_uniform_value (ClutterShaderEffect *effect,
                                                          const gchar         *name,
                                                          const GValue        *value);
 
+CLUTTER_AVAILABLE_IN_1_4
 CoglHandle      clutter_shader_effect_get_shader        (ClutterShaderEffect *effect);
+CLUTTER_AVAILABLE_IN_1_4
 CoglHandle      clutter_shader_effect_get_program       (ClutterShaderEffect *effect);
 
 G_END_DECLS
diff --git a/clutter/clutter-shader-types.h b/clutter/clutter-shader-types.h
index 21e54f3..0906243 100644
--- a/clutter/clutter-shader-types.h
+++ b/clutter/clutter-shader-types.h
@@ -28,7 +28,7 @@
 #ifndef __CLUTTER_SHADER_TYPES_H__
 #define __CLUTTER_SHADER_TYPES_H__
 
-#include <glib-object.h>
+#include <clutter/clutter-types.h>
 
 G_BEGIN_DECLS
 
@@ -70,23 +70,32 @@ typedef struct _ClutterShaderMatrix   ClutterShaderMatrix;
  */
 #define CLUTTER_VALUE_HOLDS_SHADER_MATRIX(x) (G_VALUE_HOLDS ((x), CLUTTER_TYPE_SHADER_MATRIX))
 
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_shader_float_get_type  (void) G_GNUC_CONST;
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_shader_int_get_type    (void) G_GNUC_CONST;
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_shader_matrix_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_0
 void            clutter_value_set_shader_float  (GValue       *value,
                                                  gint          size,
                                                  const gfloat *floats);
+CLUTTER_AVAILABLE_IN_1_0
 void            clutter_value_set_shader_int    (GValue       *value,
                                                  gint          size,
                                                  const gint   *ints);
+CLUTTER_AVAILABLE_IN_1_0
 void            clutter_value_set_shader_matrix (GValue       *value,
                                                  gint          size,
                                                  const gfloat *matrix);
+CLUTTER_AVAILABLE_IN_1_0
 const gfloat *  clutter_value_get_shader_float  (const GValue *value,
                                                  gsize        *length);
+CLUTTER_AVAILABLE_IN_1_0
 const gint   *  clutter_value_get_shader_int    (const GValue *value,
                                                  gsize        *length);
+CLUTTER_AVAILABLE_IN_1_0
 const gfloat *  clutter_value_get_shader_matrix (const GValue *value,
                                                  gsize        *length);
 
diff --git a/clutter/clutter-snap-constraint.h b/clutter/clutter-snap-constraint.h
index e27821e..5c42e92 100644
--- a/clutter/clutter-snap-constraint.h
+++ b/clutter/clutter-snap-constraint.h
@@ -48,24 +48,32 @@ G_BEGIN_DECLS
 typedef struct _ClutterSnapConstraint           ClutterSnapConstraint;
 typedef struct _ClutterSnapConstraintClass      ClutterSnapConstraintClass;
 
+CLUTTER_AVAILABLE_IN_1_6
 GType clutter_snap_constraint_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_6
 ClutterConstraint *     clutter_snap_constraint_new             (ClutterActor          *source,
                                                                  ClutterSnapEdge        from_edge,
                                                                  ClutterSnapEdge        to_edge,
                                                                  gfloat                 offset);
 
+CLUTTER_AVAILABLE_IN_1_6
 void                    clutter_snap_constraint_set_source      (ClutterSnapConstraint *constraint,
                                                                  ClutterActor          *source);
+CLUTTER_AVAILABLE_IN_1_6
 ClutterActor *          clutter_snap_constraint_get_source      (ClutterSnapConstraint *constraint);
+CLUTTER_AVAILABLE_IN_1_6
 void                    clutter_snap_constraint_set_edges       (ClutterSnapConstraint *constraint,
                                                                  ClutterSnapEdge        from_edge,
                                                                  ClutterSnapEdge        to_edge);
+CLUTTER_AVAILABLE_IN_1_6
 void                    clutter_snap_constraint_get_edges       (ClutterSnapConstraint *constraint,
                                                                  ClutterSnapEdge       *from_edge,
                                                                  ClutterSnapEdge       *to_edge);
+CLUTTER_AVAILABLE_IN_1_6
 void                    clutter_snap_constraint_set_offset      (ClutterSnapConstraint *constraint,
                                                                  gfloat                 offset);
+CLUTTER_AVAILABLE_IN_1_6
 gfloat                  clutter_snap_constraint_get_offset      (ClutterSnapConstraint *constraint);
 
 G_END_DECLS
diff --git a/clutter/clutter-stage-manager.h b/clutter/clutter-stage-manager.h
index b9174b1..2838b64 100644
--- a/clutter/clutter-stage-manager.h
+++ b/clutter/clutter-stage-manager.h
@@ -69,11 +69,16 @@ struct _ClutterStageManagerClass
                           ClutterStage        *stage);
 };
 
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_stage_manager_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_0
 ClutterStageManager *clutter_stage_manager_get_default       (void);
+CLUTTER_AVAILABLE_IN_1_0
 ClutterStage *       clutter_stage_manager_get_default_stage (ClutterStageManager *stage_manager);
+CLUTTER_AVAILABLE_IN_1_0
 GSList *             clutter_stage_manager_list_stages       (ClutterStageManager *stage_manager);
+CLUTTER_AVAILABLE_IN_1_0
 const GSList *       clutter_stage_manager_peek_stages       (ClutterStageManager *stage_manager);
 
 G_END_DECLS
diff --git a/clutter/clutter-stage.h b/clutter/clutter-stage.h
index 36044c0..70d4b7f 100644
--- a/clutter/clutter-stage.h
+++ b/clutter/clutter-stage.h
@@ -135,71 +135,106 @@ struct _ClutterFog
   gfloat z_far;
 };
 
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_perspective_get_type (void) G_GNUC_CONST;
+CLUTTER_DEPRECATED_IN_1_10
 GType clutter_fog_get_type (void) G_GNUC_CONST;
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_stage_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor *  clutter_stage_new                               (void);
 
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_set_perspective                   (ClutterStage          *stage,
                                                                 ClutterPerspective    *perspective);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_get_perspective                   (ClutterStage          *stage,
                                                                 ClutterPerspective    *perspective);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_set_fullscreen                    (ClutterStage          *stage,
                                                                  gboolean               fullscreen);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean        clutter_stage_get_fullscreen                    (ClutterStage          *stage);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_show_cursor                       (ClutterStage          *stage);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_hide_cursor                       (ClutterStage          *stage);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_set_title                         (ClutterStage          *stage,
                                                                  const gchar           *title);
+CLUTTER_AVAILABLE_IN_ALL
 const gchar *   clutter_stage_get_title                         (ClutterStage          *stage);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_set_user_resizable                (ClutterStage          *stage,
                                                                 gboolean               resizable);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean        clutter_stage_get_user_resizable                (ClutterStage          *stage);
 
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_set_minimum_size                  (ClutterStage          *stage,
                                                                  guint                  width,
                                                                  guint                  height);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_get_minimum_size                  (ClutterStage          *stage,
                                                                  guint                 *width,
                                                                  guint                 *height);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_set_no_clear_hint                 (ClutterStage          *stage,
                                                                  gboolean               no_clear);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean        clutter_stage_get_no_clear_hint                 (ClutterStage          *stage);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_set_use_alpha                     (ClutterStage          *stage,
                                                                  gboolean               use_alpha);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean        clutter_stage_get_use_alpha                     (ClutterStage          *stage);
 
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_set_key_focus                     (ClutterStage          *stage,
                                                                  ClutterActor          *actor);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor *  clutter_stage_get_key_focus                     (ClutterStage          *stage);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_set_throttle_motion_events        (ClutterStage          *stage,
                                                                  gboolean               throttle);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean        clutter_stage_get_throttle_motion_events        (ClutterStage          *stage);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_set_motion_events_enabled         (ClutterStage          *stage,
                                                                  gboolean               enabled);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean        clutter_stage_get_motion_events_enabled         (ClutterStage          *stage);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_set_accept_focus                  (ClutterStage          *stage,
                                                                  gboolean               accept_focus);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean        clutter_stage_get_accept_focus                  (ClutterStage          *stage);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean        clutter_stage_event                             (ClutterStage          *stage,
                                                                  ClutterEvent          *event);
 
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActor *  clutter_stage_get_actor_at_pos                  (ClutterStage          *stage,
                                                                  ClutterPickMode        pick_mode,
                                                                  gint                   x,
                                                                  gint                   y);
+CLUTTER_AVAILABLE_IN_ALL
 guchar *        clutter_stage_read_pixels                       (ClutterStage          *stage,
                                                                  gint                   x,
                                                                  gint                   y,
                                                                  gint                   width,
                                                                  gint                   height);
 
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_get_redraw_clip_bounds            (ClutterStage          *stage,
                                                                  cairo_rectangle_int_t *clip);
 
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_ensure_current                    (ClutterStage          *stage);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_ensure_viewport                   (ClutterStage          *stage);
+CLUTTER_AVAILABLE_IN_ALL
 void            clutter_stage_ensure_redraw                     (ClutterStage          *stage);
 
 #ifdef CLUTTER_ENABLE_EXPERIMENTAL_API
diff --git a/clutter/clutter-swipe-action.h b/clutter/clutter-swipe-action.h
index c35b65a..ebbc204 100644
--- a/clutter/clutter-swipe-action.h
+++ b/clutter/clutter-swipe-action.h
@@ -98,8 +98,10 @@ struct _ClutterSwipeActionClass
   void (* _clutter_swipe_action6) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_8
 GType clutter_swipe_action_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_8
 ClutterAction * clutter_swipe_action_new        (void);
 
 G_END_DECLS
diff --git a/clutter/clutter-text.h b/clutter/clutter-text.h
index fd6e193..95e6a66 100644
--- a/clutter/clutter-text.h
+++ b/clutter/clutter-text.h
@@ -96,12 +96,16 @@ struct _ClutterTextClass
   void (* _clutter_reserved7) (void);
 };
 
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_text_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_0
 ClutterActor *        clutter_text_new                  (void);
+CLUTTER_AVAILABLE_IN_1_0
 ClutterActor *        clutter_text_new_full             (const gchar          *font_name,
                                                          const gchar          *text,
                                                          const ClutterColor   *color);
+CLUTTER_AVAILABLE_IN_1_0
 ClutterActor *        clutter_text_new_with_text        (const gchar          *font_name,
                                                          const gchar          *text);
 CLUTTER_AVAILABLE_IN_1_10
@@ -111,126 +115,189 @@ ClutterTextBuffer *   clutter_text_get_buffer           (ClutterText          *s
 CLUTTER_AVAILABLE_IN_1_10
 void                  clutter_text_set_buffer           (ClutterText          *self,
                                                          ClutterTextBuffer    *buffer);
+CLUTTER_AVAILABLE_IN_1_0
 const gchar *         clutter_text_get_text             (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_text             (ClutterText          *self,
                                                          const gchar          *text);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_markup           (ClutterText          *self,
                                                          const gchar          *markup);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_color            (ClutterText          *self,
                                                          const ClutterColor   *color);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_get_color            (ClutterText          *self,
                                                          ClutterColor         *color);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_font_name        (ClutterText          *self,
                                                          const gchar          *font_name);
+CLUTTER_AVAILABLE_IN_1_0
 const gchar *         clutter_text_get_font_name        (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_2
 void                  clutter_text_set_font_description (ClutterText          *self,
                                                          PangoFontDescription *font_desc);
+CLUTTER_AVAILABLE_IN_1_2
 PangoFontDescription *clutter_text_get_font_description (ClutterText          *self);
 
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_ellipsize        (ClutterText          *self,
                                                          PangoEllipsizeMode    mode);
+CLUTTER_AVAILABLE_IN_1_0
 PangoEllipsizeMode    clutter_text_get_ellipsize        (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_line_wrap        (ClutterText          *self,
                                                          gboolean              line_wrap);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean              clutter_text_get_line_wrap        (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_line_wrap_mode   (ClutterText          *self,
                                                          PangoWrapMode         wrap_mode);
+CLUTTER_AVAILABLE_IN_1_0
 PangoWrapMode         clutter_text_get_line_wrap_mode   (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 PangoLayout *         clutter_text_get_layout           (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_attributes       (ClutterText          *self,
                                                          PangoAttrList        *attrs);
+CLUTTER_AVAILABLE_IN_1_0
 PangoAttrList *       clutter_text_get_attributes       (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_use_markup       (ClutterText          *self,
                                                          gboolean              setting);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean              clutter_text_get_use_markup       (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_line_alignment   (ClutterText          *self,
                                                          PangoAlignment        alignment);
+CLUTTER_AVAILABLE_IN_1_0
 PangoAlignment        clutter_text_get_line_alignment   (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_justify          (ClutterText          *self,
                                                          gboolean              justify);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean              clutter_text_get_justify          (ClutterText          *self);
 
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_insert_unichar       (ClutterText          *self,
                                                          gunichar              wc);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_delete_chars         (ClutterText          *self,
                                                          guint                 n_chars);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_insert_text          (ClutterText          *self,
                                                          const gchar          *text,
                                                          gssize                position);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_delete_text          (ClutterText          *self,
                                                          gssize                start_pos,
                                                          gssize                end_pos);
+CLUTTER_AVAILABLE_IN_1_0
 gchar *               clutter_text_get_chars            (ClutterText          *self,
                                                          gssize                start_pos,
                                                          gssize                end_pos);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_editable         (ClutterText          *self,
                                                          gboolean              editable);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean              clutter_text_get_editable         (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_activatable      (ClutterText          *self,
                                                          gboolean              activatable);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean              clutter_text_get_activatable      (ClutterText          *self);
 
+CLUTTER_AVAILABLE_IN_1_0
 gint                  clutter_text_get_cursor_position  (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_cursor_position  (ClutterText          *self,
                                                          gint                  position);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_cursor_visible   (ClutterText          *self,
                                                          gboolean              cursor_visible);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean              clutter_text_get_cursor_visible   (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_cursor_color     (ClutterText          *self,
                                                          const ClutterColor   *color);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_get_cursor_color     (ClutterText          *self,
                                                          ClutterColor         *color);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_cursor_size      (ClutterText          *self,
                                                          gint                  size);
+CLUTTER_AVAILABLE_IN_1_0
 guint                 clutter_text_get_cursor_size      (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_16
 void                  clutter_text_get_cursor_rect      (ClutterText          *self,
                                                          ClutterRect          *rect);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_selectable       (ClutterText          *self,
                                                          gboolean              selectable);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean              clutter_text_get_selectable       (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_selection_bound  (ClutterText          *self,
                                                          gint                  selection_bound);
+CLUTTER_AVAILABLE_IN_1_0
 gint                  clutter_text_get_selection_bound  (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_selection        (ClutterText          *self,
                                                          gssize                start_pos,
                                                          gssize                end_pos);
+CLUTTER_AVAILABLE_IN_1_0
 gchar *               clutter_text_get_selection        (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_selection_color  (ClutterText          *self,
                                                          const ClutterColor   *color);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_get_selection_color  (ClutterText          *self,
                                                          ClutterColor         *color);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean              clutter_text_delete_selection     (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_password_char    (ClutterText          *self,
                                                          gunichar              wc);
+CLUTTER_AVAILABLE_IN_1_0
 gunichar              clutter_text_get_password_char    (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_max_length       (ClutterText          *self,
                                                          gint                  max);
+CLUTTER_AVAILABLE_IN_1_0
 gint                  clutter_text_get_max_length       (ClutterText          *self);
+CLUTTER_AVAILABLE_IN_1_0
 void                  clutter_text_set_single_line_mode (ClutterText          *self,
                                                          gboolean              single_line);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean              clutter_text_get_single_line_mode (ClutterText          *self);
 
+CLUTTER_AVAILABLE_IN_1_8
 void                  clutter_text_set_selected_text_color  (ClutterText          *self,
                                                              const ClutterColor   *color);
+CLUTTER_AVAILABLE_IN_1_8
 void                  clutter_text_get_selected_text_color  (ClutterText          *self,
                                                              ClutterColor         *color);
 
+CLUTTER_AVAILABLE_IN_1_0
 gboolean              clutter_text_activate             (ClutterText          *self);
 CLUTTER_AVAILABLE_IN_1_10
 gint                  clutter_text_coords_to_position   (ClutterText          *self,
                                                          gfloat                x,
                                                          gfloat                y);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean              clutter_text_position_to_coords   (ClutterText          *self,
                                                          gint                  position,
                                                          gfloat               *x,
                                                          gfloat               *y,
                                                          gfloat               *line_height);
 
+CLUTTER_AVAILABLE_IN_1_2
 void                  clutter_text_set_preedit_string   (ClutterText          *self,
                                                          const gchar          *preedit_str,
                                                          PangoAttrList        *preedit_attrs,
                                                          guint                 cursor_pos);
 
+CLUTTER_AVAILABLE_IN_1_8
 void                  clutter_text_get_layout_offsets   (ClutterText           *self,
                                                          gint                  *x,
                                                          gint                  *y);
diff --git a/clutter/clutter-texture.h b/clutter/clutter-texture.h
index 4781b2c..95fd170 100644
--- a/clutter/clutter-texture.h
+++ b/clutter/clutter-texture.h
@@ -67,6 +67,7 @@ typedef enum {
  * Since: 0.4
  */
 #define CLUTTER_TEXTURE_ERROR   (clutter_texture_error_quark ())
+CLUTTER_AVAILABLE_IN_ALL
 GQuark clutter_texture_error_quark (void);
 
 typedef struct _ClutterTexture        ClutterTexture;
@@ -121,6 +122,7 @@ struct _ClutterTextureClass
   void (*_clutter_texture5) (void);
 };
 
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_texture_get_type (void) G_GNUC_CONST;
 
 G_END_DECLS
diff --git a/clutter/clutter-timeline.h b/clutter/clutter-timeline.h
index c31f8df..267dc63 100644
--- a/clutter/clutter-timeline.h
+++ b/clutter/clutter-timeline.h
@@ -115,53 +115,78 @@ struct _ClutterTimelineClass
   void (*_clutter_timeline_4) (void);
 };
 
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_timeline_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_ALL
 ClutterTimeline *               clutter_timeline_new                            (guint                     
msecs);
 
+CLUTTER_AVAILABLE_IN_ALL
 guint                           clutter_timeline_get_duration                   (ClutterTimeline          
*timeline);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_timeline_set_duration                   (ClutterTimeline          
*timeline,
                                                                                  guint                     
msecs);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterTimelineDirection        clutter_timeline_get_direction                  (ClutterTimeline          
*timeline);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_timeline_set_direction                  (ClutterTimeline          
*timeline,
                                                                                  ClutterTimelineDirection  
direction);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_timeline_start                          (ClutterTimeline          
*timeline);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_timeline_pause                          (ClutterTimeline          
*timeline);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_timeline_stop                           (ClutterTimeline          
*timeline);
+CLUTTER_AVAILABLE_IN_1_6
 void                            clutter_timeline_set_auto_reverse               (ClutterTimeline          
*timeline,
                                                                                  gboolean                  
reverse);
+CLUTTER_AVAILABLE_IN_1_6
 gboolean                        clutter_timeline_get_auto_reverse               (ClutterTimeline          
*timeline);
 CLUTTER_AVAILABLE_IN_1_10
 void                            clutter_timeline_set_repeat_count               (ClutterTimeline          
*timeline,
                                                                                  gint                      
count);
 CLUTTER_AVAILABLE_IN_1_10
 gint                            clutter_timeline_get_repeat_count               (ClutterTimeline          
*timeline);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_timeline_rewind                         (ClutterTimeline          
*timeline);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_timeline_skip                           (ClutterTimeline          
*timeline,
                                                                                  guint                     
msecs);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_timeline_advance                        (ClutterTimeline          
*timeline,
                                                                                  guint                     
msecs);
+CLUTTER_AVAILABLE_IN_ALL
 guint                           clutter_timeline_get_elapsed_time               (ClutterTimeline          
*timeline);
+CLUTTER_AVAILABLE_IN_ALL
 gdouble                         clutter_timeline_get_progress                   (ClutterTimeline          
*timeline);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_timeline_is_playing                     (ClutterTimeline          
*timeline);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_timeline_set_delay                      (ClutterTimeline          
*timeline,
                                                                                  guint                     
msecs);
+CLUTTER_AVAILABLE_IN_ALL
 guint                           clutter_timeline_get_delay                      (ClutterTimeline          
*timeline);
+CLUTTER_AVAILABLE_IN_ALL
 guint                           clutter_timeline_get_delta                      (ClutterTimeline          
*timeline);
 CLUTTER_AVAILABLE_IN_1_14
 void                            clutter_timeline_add_marker                     (ClutterTimeline          
*timeline,
                                                                                  const gchar              
*marker_name,
                                                                                  gdouble                   
progress);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_timeline_add_marker_at_time             (ClutterTimeline          
*timeline,
                                                                                  const gchar              
*marker_name,
                                                                                  guint                     
msecs);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_timeline_remove_marker                  (ClutterTimeline          
*timeline,
                                                                                  const gchar              
*marker_name);
+CLUTTER_AVAILABLE_IN_ALL
 gchar **                        clutter_timeline_list_markers                   (ClutterTimeline          
*timeline,
                                                                                  gint                      
msecs,
                                                                                  gsize                    
*n_markers) G_GNUC_MALLOC;
+CLUTTER_AVAILABLE_IN_ALL
 gboolean                        clutter_timeline_has_marker                     (ClutterTimeline          
*timeline,
                                                                                  const gchar              
*marker_name);
+CLUTTER_AVAILABLE_IN_ALL
 void                            clutter_timeline_advance_to_marker              (ClutterTimeline          
*timeline,
                                                                                  const gchar              
*marker_name);
 CLUTTER_AVAILABLE_IN_1_10
diff --git a/clutter/clutter-types.h b/clutter/clutter-types.h
index 9a66394..ad97a63 100644
--- a/clutter/clutter-types.h
+++ b/clutter/clutter-types.h
@@ -408,18 +408,24 @@ struct _ClutterVertex
  */
 #define CLUTTER_VERTEX_INIT_ZERO        CLUTTER_VERTEX_INIT (0.f, 0.f, 0.f)
 
+CLUTTER_AVAILABLE_IN_ALL
 GType          clutter_vertex_get_type (void) G_GNUC_CONST;
+CLUTTER_AVAILABLE_IN_ALL
 ClutterVertex *clutter_vertex_new      (gfloat               x,
                                         gfloat               y,
                                         gfloat               z);
 CLUTTER_AVAILABLE_IN_1_12
 ClutterVertex *clutter_vertex_alloc    (void);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterVertex *clutter_vertex_init     (ClutterVertex       *vertex,
                                         gfloat               x,
                                         gfloat               y,
                                         gfloat               z);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterVertex *clutter_vertex_copy     (const ClutterVertex *vertex);
+CLUTTER_AVAILABLE_IN_ALL
 void           clutter_vertex_free     (ClutterVertex       *vertex);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean       clutter_vertex_equal    (const ClutterVertex *vertex_a,
                                         const ClutterVertex *vertex_b);
 
@@ -475,55 +481,76 @@ struct _ClutterActorBox
  */
 #define CLUTTER_ACTOR_BOX_INIT_ZERO                     CLUTTER_ACTOR_BOX_INIT (0.f, 0.f, 0.f, 0.f)
 
+CLUTTER_AVAILABLE_IN_ALL
 GType            clutter_actor_box_get_type      (void) G_GNUC_CONST;
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActorBox *clutter_actor_box_new           (gfloat                 x_1,
                                                   gfloat                 y_1,
                                                   gfloat                 x_2,
                                                   gfloat                 y_2);
 CLUTTER_AVAILABLE_IN_1_12
 ClutterActorBox *clutter_actor_box_alloc         (void);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActorBox *clutter_actor_box_init          (ClutterActorBox       *box,
                                                   gfloat                 x_1,
                                                   gfloat                 y_1,
                                                   gfloat                 x_2,
                                                   gfloat                 y_2);
+CLUTTER_AVAILABLE_IN_ALL
 void             clutter_actor_box_init_rect     (ClutterActorBox       *box,
                                                   gfloat                 x,
                                                   gfloat                 y,
                                                   gfloat                 width,
                                                   gfloat                 height);
+CLUTTER_AVAILABLE_IN_ALL
 ClutterActorBox *clutter_actor_box_copy          (const ClutterActorBox *box);
+CLUTTER_AVAILABLE_IN_ALL
 void             clutter_actor_box_free          (ClutterActorBox       *box);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean         clutter_actor_box_equal         (const ClutterActorBox *box_a,
                                                   const ClutterActorBox *box_b);
+CLUTTER_AVAILABLE_IN_ALL
 gfloat           clutter_actor_box_get_x         (const ClutterActorBox *box);
+CLUTTER_AVAILABLE_IN_ALL
 gfloat           clutter_actor_box_get_y         (const ClutterActorBox *box);
+CLUTTER_AVAILABLE_IN_ALL
 gfloat           clutter_actor_box_get_width     (const ClutterActorBox *box);
+CLUTTER_AVAILABLE_IN_ALL
 gfloat           clutter_actor_box_get_height    (const ClutterActorBox *box);
+CLUTTER_AVAILABLE_IN_ALL
 void             clutter_actor_box_get_origin    (const ClutterActorBox *box,
                                                   gfloat                *x,
                                                   gfloat                *y);
+CLUTTER_AVAILABLE_IN_ALL
 void             clutter_actor_box_get_size      (const ClutterActorBox *box,
                                                   gfloat                *width,
                                                   gfloat                *height);
+CLUTTER_AVAILABLE_IN_ALL
 gfloat           clutter_actor_box_get_area      (const ClutterActorBox *box);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean         clutter_actor_box_contains      (const ClutterActorBox *box,
                                                   gfloat                 x,
                                                   gfloat                 y);
+CLUTTER_AVAILABLE_IN_ALL
 void             clutter_actor_box_from_vertices (ClutterActorBox       *box,
                                                   const ClutterVertex    verts[]);
+CLUTTER_AVAILABLE_IN_ALL
 void             clutter_actor_box_interpolate   (const ClutterActorBox *initial,
                                                   const ClutterActorBox *final,
                                                   gdouble                progress,
                                                   ClutterActorBox       *result);
+CLUTTER_AVAILABLE_IN_ALL
 void             clutter_actor_box_clamp_to_pixel (ClutterActorBox       *box);
+CLUTTER_AVAILABLE_IN_ALL
 void             clutter_actor_box_union          (const ClutterActorBox *a,
                                                    const ClutterActorBox *b,
                                                    ClutterActorBox       *result);
 
+CLUTTER_AVAILABLE_IN_ALL
 void             clutter_actor_box_set_origin     (ClutterActorBox       *box,
                                                    gfloat                 x,
                                                    gfloat                 y);
+CLUTTER_AVAILABLE_IN_ALL
 void             clutter_actor_box_set_size       (ClutterActorBox       *box,
                                                    gfloat                 width,
                                                    gfloat                 height);
@@ -552,6 +579,7 @@ struct _ClutterGeometry
   guint  height;
 };
 
+CLUTTER_AVAILABLE_IN_ALL
 GType clutter_geometry_get_type (void) G_GNUC_CONST;
 
 CLUTTER_DEPRECATED_IN_1_16
@@ -577,9 +605,13 @@ struct _ClutterKnot
   gint y;
 };
 
+CLUTTER_AVAILABLE_IN_ALL
 GType        clutter_knot_get_type (void) G_GNUC_CONST;
+CLUTTER_AVAILABLE_IN_ALL
 ClutterKnot *clutter_knot_copy     (const ClutterKnot *knot);
+CLUTTER_AVAILABLE_IN_ALL
 void         clutter_knot_free     (ClutterKnot       *knot);
+CLUTTER_AVAILABLE_IN_ALL
 gboolean     clutter_knot_equal    (const ClutterKnot *knot_a,
                                     const ClutterKnot *knot_b);
 
@@ -604,10 +636,14 @@ struct _ClutterPathNode
   ClutterKnot points[3];
 };
 
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_path_node_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_0
 ClutterPathNode *clutter_path_node_copy  (const ClutterPathNode *node);
+CLUTTER_AVAILABLE_IN_1_0
 void             clutter_path_node_free  (ClutterPathNode       *node);
+CLUTTER_AVAILABLE_IN_1_0
 gboolean         clutter_path_node_equal (const ClutterPathNode *node_a,
                                           const ClutterPathNode *node_b);
 
@@ -615,30 +651,43 @@ gboolean         clutter_path_node_equal (const ClutterPathNode *node_a,
  * ClutterPaintVolume
  */
 
+CLUTTER_AVAILABLE_IN_1_2
 GType clutter_paint_volume_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_2
 ClutterPaintVolume *clutter_paint_volume_copy                (const ClutterPaintVolume *pv);
+CLUTTER_AVAILABLE_IN_1_2
 void                clutter_paint_volume_free                (ClutterPaintVolume       *pv);
 
+CLUTTER_AVAILABLE_IN_1_2
 void                clutter_paint_volume_set_origin          (ClutterPaintVolume       *pv,
                                                               const ClutterVertex      *origin);
+CLUTTER_AVAILABLE_IN_1_2
 void                clutter_paint_volume_get_origin          (const ClutterPaintVolume *pv,
                                                               ClutterVertex            *vertex);
+CLUTTER_AVAILABLE_IN_1_2
 void                clutter_paint_volume_set_width           (ClutterPaintVolume       *pv,
                                                               gfloat                    width);
+CLUTTER_AVAILABLE_IN_1_2
 gfloat              clutter_paint_volume_get_width           (const ClutterPaintVolume *pv);
+CLUTTER_AVAILABLE_IN_1_2
 void                clutter_paint_volume_set_height          (ClutterPaintVolume       *pv,
                                                               gfloat                    height);
+CLUTTER_AVAILABLE_IN_1_2
 gfloat              clutter_paint_volume_get_height          (const ClutterPaintVolume *pv);
+CLUTTER_AVAILABLE_IN_1_2
 void                clutter_paint_volume_set_depth           (ClutterPaintVolume       *pv,
                                                               gfloat                    depth);
+CLUTTER_AVAILABLE_IN_1_2
 gfloat              clutter_paint_volume_get_depth           (const ClutterPaintVolume *pv);
+CLUTTER_AVAILABLE_IN_1_2
 void                clutter_paint_volume_union               (ClutterPaintVolume       *pv,
                                                               const ClutterPaintVolume *another_pv);
 CLUTTER_AVAILABLE_IN_1_10
 void                clutter_paint_volume_union_box           (ClutterPaintVolume       *pv,
                                                               const ClutterActorBox    *box);
 
+CLUTTER_AVAILABLE_IN_1_2
 gboolean            clutter_paint_volume_set_from_allocation (ClutterPaintVolume       *pv,
                                                               ClutterActor             *actor);
 
@@ -661,10 +710,14 @@ struct _ClutterMargin
   float bottom;
 };
 
+CLUTTER_AVAILABLE_IN_1_10
 GType clutter_margin_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_10
 ClutterMargin * clutter_margin_new      (void) G_GNUC_MALLOC;
+CLUTTER_AVAILABLE_IN_1_10
 ClutterMargin * clutter_margin_copy     (const ClutterMargin *margin_);
+CLUTTER_AVAILABLE_IN_1_10
 void            clutter_margin_free     (ClutterMargin       *margin_);
 
 /**
@@ -695,6 +748,7 @@ typedef gboolean (* ClutterProgressFunc) (const GValue *a,
                                           gdouble       progress,
                                           GValue       *retval);
 
+CLUTTER_AVAILABLE_IN_1_0
 void clutter_interval_register_progress_func (GType               value_type,
                                               ClutterProgressFunc func);
 
diff --git a/clutter/clutter-units.h b/clutter/clutter-units.h
index e50242b..c558b10 100644
--- a/clutter/clutter-units.h
+++ b/clutter/clutter-units.h
@@ -70,31 +70,45 @@ struct _ClutterUnits
   gint64 __padding_2;
 };
 
+CLUTTER_AVAILABLE_IN_1_0
 GType           clutter_units_get_type         (void) G_GNUC_CONST;
+CLUTTER_AVAILABLE_IN_1_0
 ClutterUnitType clutter_units_get_unit_type    (const ClutterUnits *units);
+CLUTTER_AVAILABLE_IN_1_0
 gfloat          clutter_units_get_unit_value   (const ClutterUnits *units);
 
+CLUTTER_AVAILABLE_IN_1_0
 ClutterUnits *  clutter_units_copy             (const ClutterUnits *units);
+CLUTTER_AVAILABLE_IN_1_0
 void            clutter_units_free             (ClutterUnits       *units);
 
+CLUTTER_AVAILABLE_IN_1_0
 void            clutter_units_from_pixels      (ClutterUnits       *units,
                                                 gint                px);
+CLUTTER_AVAILABLE_IN_1_0
 void            clutter_units_from_em          (ClutterUnits       *units,
                                                 gfloat              em);
+CLUTTER_AVAILABLE_IN_1_0
 void            clutter_units_from_em_for_font (ClutterUnits       *units,
                                                 const gchar        *font_name,
                                                 gfloat              em);
+CLUTTER_AVAILABLE_IN_1_0
 void            clutter_units_from_mm          (ClutterUnits       *units,
                                                 gfloat              mm);
+CLUTTER_AVAILABLE_IN_1_0
 void            clutter_units_from_cm          (ClutterUnits       *units,
                                                 gfloat              cm);
+CLUTTER_AVAILABLE_IN_1_0
 void            clutter_units_from_pt          (ClutterUnits       *units,
                                                 gfloat              pt);
 
+CLUTTER_AVAILABLE_IN_1_0
 gfloat          clutter_units_to_pixels        (ClutterUnits       *units);
 
+CLUTTER_AVAILABLE_IN_1_0
 gboolean        clutter_units_from_string      (ClutterUnits       *units,
                                                 const gchar        *str);
+CLUTTER_AVAILABLE_IN_1_0
 gchar *         clutter_units_to_string        (const ClutterUnits *units);
 
 /* shorthands for the constructors */
@@ -146,8 +160,10 @@ struct _ClutterParamSpecUnits
   gfloat maximum;
 };
 
+CLUTTER_AVAILABLE_IN_1_0
 GType clutter_param_units_get_type (void) G_GNUC_CONST;
 
+CLUTTER_AVAILABLE_IN_1_0
 GParamSpec *            clutter_param_spec_units (const gchar        *name,
                                                   const gchar        *nick,
                                                   const gchar        *blurb,
@@ -157,8 +173,10 @@ GParamSpec *            clutter_param_spec_units (const gchar        *name,
                                                   gfloat              default_value,
                                                   GParamFlags         flags);
 
+CLUTTER_AVAILABLE_IN_1_0
 void                    clutter_value_set_units  (GValue             *value,
                                                   const ClutterUnits *units);
+CLUTTER_AVAILABLE_IN_1_0
 const ClutterUnits *    clutter_value_get_units  (const GValue       *value);
 
 G_END_DECLS
diff --git a/clutter/clutter-version.h.in b/clutter/clutter-version.h.in
index 44114c9..a308920 100644
--- a/clutter/clutter-version.h.in
+++ b/clutter/clutter-version.h.in
@@ -311,12 +311,6 @@ CLUTTER_VAR const guint clutter_minor_version;
  */
 CLUTTER_VAR const guint clutter_micro_version;
 
-gboolean clutter_check_version (guint major,
-                                guint minor,
-                                guint micro);
-
-gboolean clutter_check_windowing_backend (const char *backend_type);
-
 G_END_DECLS
 
 #endif /* __CLUTTER_VERSION_H__ */
diff --git a/clutter/clutter.h b/clutter/clutter.h
index 4a612b7..cb7985a 100644
--- a/clutter/clutter.h
+++ b/clutter/clutter.h
@@ -61,6 +61,7 @@
 #include "clutter-drop-action.h"
 #include "clutter-effect.h"
 #include "clutter-enums.h"
+#include "clutter-enum-types.h"
 #include "clutter-event.h"
 #include "clutter-feature.h"
 #include "clutter-fixed-layout.h"
@@ -109,8 +110,6 @@
 #include "clutter-version.h"
 #include "clutter-zoom-action.h"
 
-#include "clutter-enum-types.h"
-
 #include "clutter-deprecated.h"
 
 #undef __CLUTTER_H_INSIDE__
diff --git a/clutter/deprecated/clutter-fixed.h b/clutter/deprecated/clutter-fixed.h
index c756ef4..215e626 100644
--- a/clutter/deprecated/clutter-fixed.h
+++ b/clutter/deprecated/clutter-fixed.h
@@ -75,6 +75,7 @@ struct _ClutterParamSpecFixed
   CoglFixed default_value;
 };
 
+CLUTTER_DEPRECATED_IN_1_10
 GType        clutter_param_fixed_get_type (void) G_GNUC_CONST;
 
 CLUTTER_DEPRECATED_IN_1_10_FOR(g_value_set_int)


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]