<MACRO>
<NAME>GES_PADDING</NAME>
#define GES_PADDING         4
</MACRO>
<MACRO>
<NAME>GES_PADDING_LARGE</NAME>
#define GES_PADDING_LARGE   20
</MACRO>
<STRUCT>
<NAME>GESAsset</NAME>
</STRUCT>
<STRUCT>
<NAME>GESAssetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESAudioSource</NAME>
</STRUCT>
<STRUCT>
<NAME>GESAudioSourceClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESAudioTestSource</NAME>
</STRUCT>
<STRUCT>
<NAME>GESAudioTrack</NAME>
</STRUCT>
<STRUCT>
<NAME>GESAudioTrackClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESAudioTransition</NAME>
</STRUCT>
<STRUCT>
<NAME>GESAudioUriSource</NAME>
</STRUCT>
<STRUCT>
<NAME>GESAudioUriSourceClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESBaseEffect</NAME>
</STRUCT>
<STRUCT>
<NAME>GESBaseEffectClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESBaseEffectClip</NAME>
</STRUCT>
<STRUCT>
<NAME>GESBaseEffectClipClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESBaseTransitionClip</NAME>
</STRUCT>
<STRUCT>
<NAME>GESBaseTransitionClipClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESClip</NAME>
</STRUCT>
<STRUCT>
<NAME>GESClipAsset</NAME>
</STRUCT>
<STRUCT>
<NAME>GESClipAssetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESClipClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESContainer</NAME>
</STRUCT>
<STRUCT>
<NAME>GESContainerClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESEffect</NAME>
</STRUCT>
<STRUCT>
<NAME>GESEffectClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESEffectClip</NAME>
</STRUCT>
<STRUCT>
<NAME>GESEffectClipClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESExtractable</NAME>
</STRUCT>
<STRUCT>
<NAME>GESExtractableInterface</NAME>
</STRUCT>
<STRUCT>
<NAME>GESFormatter</NAME>
</STRUCT>
<STRUCT>
<NAME>GESFormatterClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESGroup</NAME>
</STRUCT>
<STRUCT>
<NAME>GESGroupClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESImageSource</NAME>
</STRUCT>
<STRUCT>
<NAME>GESImageSourceClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESLayer</NAME>
</STRUCT>
<STRUCT>
<NAME>GESLayerClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESMultiFileSource</NAME>
</STRUCT>
<STRUCT>
<NAME>GESMultiFileSourceClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESOperation</NAME>
</STRUCT>
<STRUCT>
<NAME>GESOperationClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESOperationClip</NAME>
</STRUCT>
<STRUCT>
<NAME>GESOperationClipClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESOverlayClip</NAME>
</STRUCT>
<STRUCT>
<NAME>GESOverlayClipClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESPipeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GESPipelineClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESPitiviFormatter</NAME>
</STRUCT>
<STRUCT>
<NAME>GESPitiviFormatterClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESProject</NAME>
</STRUCT>
<STRUCT>
<NAME>GESProjectClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESSource</NAME>
</STRUCT>
<STRUCT>
<NAME>GESSourceClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESSourceClip</NAME>
</STRUCT>
<STRUCT>
<NAME>GESSourceClipClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTestClip</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTestClipClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTextOverlay</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTextOverlayClip</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTextOverlayClipClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTimeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTimelineClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTimelineElement</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTimelineElementClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTitleClip</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTitleClipClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTitleSource</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTrack</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTrackClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTrackElement</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTrackElementAsset</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTrackElementAssetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTrackElementClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTransition</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTransitionClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTransitionClip</NAME>
</STRUCT>
<STRUCT>
<NAME>GESTransitionClipClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESUriClip</NAME>
</STRUCT>
<STRUCT>
<NAME>GESUriClipAsset</NAME>
</STRUCT>
<STRUCT>
<NAME>GESUriClipAssetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESUriClipClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESUriSourceAsset</NAME>
</STRUCT>
<STRUCT>
<NAME>GESUriSourceAssetClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESVideoSource</NAME>
</STRUCT>
<STRUCT>
<NAME>GESVideoSourceClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESVideoTestSource</NAME>
</STRUCT>
<STRUCT>
<NAME>GESVideoTrack</NAME>
</STRUCT>
<STRUCT>
<NAME>GESVideoTrackClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GESVideoTransition</NAME>
</STRUCT>
<STRUCT>
<NAME>GESVideoUriSource</NAME>
</STRUCT>
<STRUCT>
<NAME>GESVideoUriSourceClass</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_ASSET</NAME>
#define GES_TYPE_ASSET ges_asset_get_type()
</MACRO>
<MACRO>
<NAME>GES_ASSET</NAME>
#define GES_ASSET(obj) \
    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_ASSET, GESAsset))
</MACRO>
<MACRO>
<NAME>GES_ASSET_CLASS</NAME>
#define GES_ASSET_CLASS(klass) \
    (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_ASSET, GESAssetClass))
</MACRO>
<MACRO>
<NAME>GES_IS_ASSET</NAME>
#define GES_IS_ASSET(obj) \
    (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_ASSET))
</MACRO>
<MACRO>
<NAME>GES_IS_ASSET_CLASS</NAME>
#define GES_IS_ASSET_CLASS(klass) \
    (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_ASSET))
</MACRO>
<MACRO>
<NAME>GES_ASSET_GET_CLASS</NAME>
#define GES_ASSET_GET_CLASS(obj) \
    (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_ASSET, GESAssetClass))
</MACRO>
<ENUM>
<NAME>GESAssetLoadingReturn</NAME>
typedef enum
{
  GES_ASSET_LOADING_ERROR,
  GES_ASSET_LOADING_ASYNC,
  GES_ASSET_LOADING_OK
} GESAssetLoadingReturn;
</ENUM>
<FUNCTION>
<NAME>ges_asset_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESAsset</NAME>
struct _GESAsset
{
  GObject parent;

  /* <private> */
  GESAssetPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESAssetClass</NAME>
struct _GESAssetClass
{
  GObjectClass parent;

  GESAssetLoadingReturn    (*start_loading)     (GESAsset *self,
                                                 GError **error);
  GESExtractable*          (*extract)           (GESAsset *self,
                                                 GError **error);
  /* Let subclasses know that we proxied an asset */
  void                     (*inform_proxy)      (GESAsset *self,
                                                 const gchar *proxy_id);

  void                     (*proxied)      (GESAsset *self,
                                            GESAsset *proxy);

  /* Ask subclasses for a new ID for @self when the asset failed loading
   * This function returns %FALSE when the ID could be updated or %TRUE
   * otherwize */
  gboolean                 (*request_id_update) (GESAsset *self,
                                                 gchar **proposed_new_id,
                                                 GError *error) ;
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_asset_get_extractable_type</NAME>
<RETURNS>GType  </RETURNS>
GESAsset * self
</FUNCTION>
<FUNCTION>
<NAME>ges_asset_request_async</NAME>
<RETURNS>void  </RETURNS>
GType extractable_type, const gchar * id, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>ges_asset_request</NAME>
<RETURNS>GESAsset  * </RETURNS>
GType extractable_type, const gchar * id, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ges_asset_get_id</NAME>
<RETURNS>const gchar  * </RETURNS>
GESAsset* self
</FUNCTION>
<FUNCTION>
<NAME>ges_asset_request_finish</NAME>
<RETURNS>GESAsset  * </RETURNS>
GAsyncResult *res, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ges_asset_get_error</NAME>
<RETURNS>GError  * </RETURNS>
GESAsset * self
</FUNCTION>
<FUNCTION>
<NAME>ges_asset_extract</NAME>
<RETURNS>GESExtractable  * </RETURNS>
GESAsset * self, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ges_list_assets</NAME>
<RETURNS>GList  * </RETURNS>
GType filter
</FUNCTION>
<FUNCTION>
<NAME>ges_asset_set_proxy</NAME>
<RETURNS>gboolean  </RETURNS>
GESAsset *asset, GESAsset *proxy
</FUNCTION>
<FUNCTION>
<NAME>ges_asset_unproxy</NAME>
<RETURNS>gboolean  </RETURNS>
GESAsset *asset, GESAsset * proxy
</FUNCTION>
<FUNCTION>
<NAME>ges_asset_list_proxies</NAME>
<RETURNS>GList  * </RETURNS>
GESAsset *asset
</FUNCTION>
<FUNCTION>
<NAME>ges_asset_get_proxy_target</NAME>
<RETURNS>GESAsset  * </RETURNS>
GESAsset *proxy
</FUNCTION>
<FUNCTION>
<NAME>ges_asset_get_proxy</NAME>
<RETURNS>GESAsset  * </RETURNS>
GESAsset *asset
</FUNCTION>
<FUNCTION>
<NAME>ges_asset_needs_reload</NAME>
<RETURNS>gboolean  </RETURNS>
GType extractable_type, const gchar * id
</FUNCTION>
<STRUCT>
<NAME>GESAssetPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_AUDIO_SOURCE</NAME>
#define GES_TYPE_AUDIO_SOURCE ges_audio_source_get_type()
</MACRO>
<MACRO>
<NAME>GES_AUDIO_SOURCE</NAME>
#define GES_AUDIO_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_AUDIO_SOURCE, GESAudioSource))
</MACRO>
<MACRO>
<NAME>GES_AUDIO_SOURCE_CLASS</NAME>
#define GES_AUDIO_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_AUDIO_SOURCE, GESAudioSourceClass))
</MACRO>
<MACRO>
<NAME>GES_IS_AUDIO_SOURCE</NAME>
#define GES_IS_AUDIO_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_AUDIO_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_IS_AUDIO_SOURCE_CLASS</NAME>
#define GES_IS_AUDIO_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_AUDIO_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_AUDIO_SOURCE_GET_CLASS</NAME>
#define GES_AUDIO_SOURCE_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_AUDIO_SOURCE, GESAudioSourceClass))
</MACRO>
<STRUCT>
<NAME>GESAudioSource</NAME>
struct _GESAudioSource {
  /*< private >*/
  GESSource parent;

  GESAudioSourcePrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESAudioSourceClass</NAME>
struct _GESAudioSourceClass {
  /*< private >*/
  GESSourceClass parent_class;

  /*< public >*/
  GstElement*  (*create_source)           (GESTrackElement * object);

  /*< private >*/
  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_audio_source_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESAudioSourcePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_AUDIO_TEST_SOURCE</NAME>
#define GES_TYPE_AUDIO_TEST_SOURCE ges_audio_test_source_get_type()
</MACRO>
<MACRO>
<NAME>GES_AUDIO_TEST_SOURCE</NAME>
#define GES_AUDIO_TEST_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_AUDIO_TEST_SOURCE, GESAudioTestSource))
</MACRO>
<MACRO>
<NAME>GES_AUDIO_TEST_SOURCE_CLASS</NAME>
#define GES_AUDIO_TEST_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_AUDIO_TEST_SOURCE, GESAudioTestSourceClass))
</MACRO>
<MACRO>
<NAME>GES_IS_AUDIO_TEST_SOURCE</NAME>
#define GES_IS_AUDIO_TEST_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_AUDIO_TEST_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_IS_AUDIO_TEST_SOURCE_CLASS</NAME>
#define GES_IS_AUDIO_TEST_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_AUDIO_TEST_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_AUDIO_TEST_SOURCE_GET_CLASS</NAME>
#define GES_AUDIO_TEST_SOURCE_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_AUDIO_TEST_SOURCE, GESAudioTestSourceClass))
</MACRO>
<STRUCT>
<NAME>GESAudioTestSource</NAME>
struct _GESAudioTestSource {
  GESAudioSource parent;

  /*< private >*/
  GESAudioTestSourcePrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESAudioTestSourceClass</NAME>
struct _GESAudioTestSourceClass {
  /*< private >*/
  GESAudioSourceClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_audio_test_source_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_audio_test_source_set_freq</NAME>
<RETURNS>void  </RETURNS>
GESAudioTestSource *self, gdouble freq
</FUNCTION>
<FUNCTION>
<NAME>ges_audio_test_source_set_volume</NAME>
<RETURNS>void  </RETURNS>
GESAudioTestSource *self, gdouble volume
</FUNCTION>
<FUNCTION>
<NAME>ges_audio_test_source_get_freq</NAME>
<RETURNS>double  </RETURNS>
GESAudioTestSource *self
</FUNCTION>
<FUNCTION>
<NAME>ges_audio_test_source_get_volume</NAME>
<RETURNS>double  </RETURNS>
GESAudioTestSource *self
</FUNCTION>
<STRUCT>
<NAME>GESAudioTestSourcePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_AUDIO_TRACK</NAME>
#define GES_TYPE_AUDIO_TRACK             (ges_audio_track_get_type ())
</MACRO>
<MACRO>
<NAME>GES_AUDIO_TRACK</NAME>
#define GES_AUDIO_TRACK(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_AUDIO_TRACK, GESAudioTrack))
</MACRO>
<MACRO>
<NAME>GES_AUDIO_TRACK_CLASS</NAME>
#define GES_AUDIO_TRACK_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_AUDIO_TRACK, GESAudioTrackClass))
</MACRO>
<MACRO>
<NAME>GES_IS_AUDIO_TRACK</NAME>
#define GES_IS_AUDIO_TRACK(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_AUDIO_TRACK))
</MACRO>
<MACRO>
<NAME>GES_IS_AUDIO_TRACK_CLASS</NAME>
#define GES_IS_AUDIO_TRACK_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_AUDIO_TRACK))
</MACRO>
<MACRO>
<NAME>GES_AUDIO_TRACK_GET_CLASS</NAME>
#define GES_AUDIO_TRACK_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_AUDIO_TRACK, GESAudioTrackClass))
</MACRO>
<STRUCT>
<NAME>GESAudioTrackClass</NAME>
struct _GESAudioTrackClass
{
  GESTrackClass parent_class;

  /* Padding for API extension */
  gpointer    _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESAudioTrack</NAME>
struct _GESAudioTrack
{
  GESTrack parent_instance;

  /*< private >*/
  GESAudioTrackPrivate *priv;
  /* Padding for API extension */
  gpointer         _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_audio_track_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_audio_track_new</NAME>
<RETURNS>GESAudioTrack * </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESAudioTrackPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_AUDIO_TRANSITION</NAME>
#define GES_TYPE_AUDIO_TRANSITION ges_audio_transition_get_type()
</MACRO>
<MACRO>
<NAME>GES_AUDIO_TRANSITION</NAME>
#define GES_AUDIO_TRANSITION(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_AUDIO_TRANSITION, GESAudioTransition))
</MACRO>
<MACRO>
<NAME>GES_AUDIO_TRANSITION_CLASS</NAME>
#define GES_AUDIO_TRANSITION_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_AUDIO_TRANSITION, GESAudioTransitionClass))
</MACRO>
<MACRO>
<NAME>GES_IS_AUDIO_TRANSITION</NAME>
#define GES_IS_AUDIO_TRANSITION(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_AUDIO_TRANSITION))
</MACRO>
<MACRO>
<NAME>GES_IS_AUDIO_TRANSITION_CLASS</NAME>
#define GES_IS_AUDIO_TRANSITION_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_AUDIO_TRANSITION))
</MACRO>
<MACRO>
<NAME>GES_AUDIO_TRANSITION_GET_CLASS</NAME>
#define GES_AUDIO_TRANSITION_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_AUDIO_TRANSITION, GESAudioTransitionClass))
</MACRO>
<STRUCT>
<NAME>GESAudioTransition</NAME>
struct _GESAudioTransition {
  GESTransition parent;

  /*< private >*/
  GESAudioTransitionPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESAudioTransitionClass</NAME>
struct _GESAudioTransitionClass {
  GESTransitionClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_audio_transition_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_audio_transition_new</NAME>
<RETURNS>GESAudioTransition * </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESAudioTransitionPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_AUDIO_URI_SOURCE</NAME>
#define GES_TYPE_AUDIO_URI_SOURCE ges_audio_uri_source_get_type()
</MACRO>
<MACRO>
<NAME>GES_AUDIO_URI_SOURCE</NAME>
#define GES_AUDIO_URI_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_AUDIO_URI_SOURCE, GESAudioUriSource))
</MACRO>
<MACRO>
<NAME>GES_AUDIO_URI_SOURCE_CLASS</NAME>
#define GES_AUDIO_URI_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_AUDIO_URI_SOURCE, GESAudioUriSourceClass))
</MACRO>
<MACRO>
<NAME>GES_IS_AUDIO_URI_SOURCE</NAME>
#define GES_IS_AUDIO_URI_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_AUDIO_URI_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_IS_AUDIO_URI_SOURCE_CLASS</NAME>
#define GES_IS_AUDIO_URI_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_AUDIO_URI_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_AUDIO_URI_SOURCE_GET_CLASS</NAME>
#define GES_AUDIO_URI_SOURCE_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_AUDIO_URI_SOURCE, GESAudioUriSourceClass))
</MACRO>
<STRUCT>
<NAME>GESAudioUriSource</NAME>
struct _GESAudioUriSource {
  /*< private >*/
  GESAudioSource parent;

  gchar *uri;

  GESAudioUriSourcePrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESAudioUriSourceClass</NAME>
struct _GESAudioUriSourceClass {
  /*< private >*/
  GESAudioSourceClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_audio_uri_source_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESAudioUriSourcePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_BASE_EFFECT_CLIP</NAME>
#define GES_TYPE_BASE_EFFECT_CLIP ges_base_effect_clip_get_type()
</MACRO>
<MACRO>
<NAME>GES_BASE_EFFECT_CLIP</NAME>
#define GES_BASE_EFFECT_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_BASE_EFFECT_CLIP, GESBaseEffectClip))
</MACRO>
<MACRO>
<NAME>GES_BASE_EFFECT_CLIP_CLASS</NAME>
#define GES_BASE_EFFECT_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_BASE_EFFECT_CLIP, GESBaseEffectClipClass))
</MACRO>
<MACRO>
<NAME>GES_IS_BASE_EFFECT_CLIP</NAME>
#define GES_IS_BASE_EFFECT_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_BASE_EFFECT_CLIP))
</MACRO>
<MACRO>
<NAME>GES_IS_BASE_EFFECT_CLIP_CLASS</NAME>
#define GES_IS_BASE_EFFECT_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_BASE_EFFECT_CLIP))
</MACRO>
<MACRO>
<NAME>GES_BASE_EFFECT_CLIP_GET_CLASS</NAME>
#define GES_BASE_EFFECT_CLIP_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_BASE_EFFECT_CLIP, GESBaseEffectClipClass))
</MACRO>
<STRUCT>
<NAME>GESBaseEffectClip</NAME>
struct _GESBaseEffectClip {
  /*< private >*/
  GESOperationClip parent;

  GESBaseEffectClipPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESBaseEffectClipClass</NAME>
struct _GESBaseEffectClipClass {
  /*< private >*/
  GESOperationClipClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_base_effect_clip_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESBaseEffectClipPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_BASE_EFFECT</NAME>
#define GES_TYPE_BASE_EFFECT ges_base_effect_get_type()
</MACRO>
<MACRO>
<NAME>GES_BASE_EFFECT</NAME>
#define GES_BASE_EFFECT(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_BASE_EFFECT, GESBaseEffect))
</MACRO>
<MACRO>
<NAME>GES_BASE_EFFECT_CLASS</NAME>
#define GES_BASE_EFFECT_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_BASE_EFFECT, GESBaseEffectClass))
</MACRO>
<MACRO>
<NAME>GES_IS_BASE_EFFECT</NAME>
#define GES_IS_BASE_EFFECT(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_BASE_EFFECT))
</MACRO>
<MACRO>
<NAME>GES_IS_BASE_EFFECT_CLASS</NAME>
#define GES_IS_BASE_EFFECT_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_BASE_EFFECT))
</MACRO>
<MACRO>
<NAME>GES_BASE_EFFECT_GET_CLASS</NAME>
#define GES_BASE_EFFECT_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_BASE_EFFECT, GESBaseEffectClass))
</MACRO>
<STRUCT>
<NAME>GESBaseEffect</NAME>
struct _GESBaseEffect
{
  /*< private > */
  GESOperation parent;
  GESBaseEffectPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESBaseEffectClass</NAME>
struct _GESBaseEffectClass
{
  /*< private > */
  GESOperationClass parent_class;
  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];

};
</STRUCT>
<FUNCTION>
<NAME>ges_base_effect_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESBaseEffectPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_BASE_TRANSITION_CLIP</NAME>
#define GES_TYPE_BASE_TRANSITION_CLIP ges_base_transition_clip_get_type()
</MACRO>
<MACRO>
<NAME>GES_BASE_TRANSITION_CLIP</NAME>
#define GES_BASE_TRANSITION_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_BASE_TRANSITION_CLIP, GESBaseTransitionClip))
</MACRO>
<MACRO>
<NAME>GES_BASE_TRANSITION_CLIP_CLASS</NAME>
#define GES_BASE_TRANSITION_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_BASE_TRANSITION_CLIP, GESBaseTransitionClipClass))
</MACRO>
<MACRO>
<NAME>GES_IS_BASE_TRANSITION_CLIP</NAME>
#define GES_IS_BASE_TRANSITION_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_BASE_TRANSITION_CLIP))
</MACRO>
<MACRO>
<NAME>GES_IS_BASE_TRANSITION_CLIP_CLASS</NAME>
#define GES_IS_BASE_TRANSITION_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_BASE_TRANSITION_CLIP))
</MACRO>
<MACRO>
<NAME>GES_BASE_TRANSITION_CLIP_GET_CLASS</NAME>
#define GES_BASE_TRANSITION_CLIP_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_BASE_TRANSITION_CLIP, GESBaseTransitionClipClass))
</MACRO>
<STRUCT>
<NAME>GESBaseTransitionClip</NAME>
struct _GESBaseTransitionClip {
  /*< private >*/
  GESOperationClip parent;

  /*< private >*/
  GESBaseTransitionClipPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESBaseTransitionClipClass</NAME>
struct _GESBaseTransitionClipClass {
  /*< private >*/
  GESOperationClipClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_base_transition_clip_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESBaseTransitionClipPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_BASE_XML_FORMATTER</NAME>
#define GES_TYPE_BASE_XML_FORMATTER (ges_base_xml_formatter_get_type ())
</MACRO>
<MACRO>
<NAME>GES_BASE_XML_FORMATTER</NAME>
#define GES_BASE_XML_FORMATTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_BASE_XML_FORMATTER, GESBaseXmlFormatter))
</MACRO>
<MACRO>
<NAME>GES_BASE_XML_FORMATTER_CLASS</NAME>
#define GES_BASE_XML_FORMATTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_BASE_XML_FORMATTER, GESBaseXmlFormatterClass))
</MACRO>
<MACRO>
<NAME>GES_IS_BASE_XML_FORMATTER</NAME>
#define GES_IS_BASE_XML_FORMATTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_BASE_XML_FORMATTER))
</MACRO>
<MACRO>
<NAME>GES_IS_BASE_XML_FORMATTER_CLASS</NAME>
#define GES_IS_BASE_XML_FORMATTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_BASE_XML_FORMATTER))
</MACRO>
<MACRO>
<NAME>GES_BASE_XML_FORMATTER_GET_CLASS</NAME>
#define GES_BASE_XML_FORMATTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_BASE_XML_FORMATTER, GESBaseXmlFormatterClass))
</MACRO>
<STRUCT>
<NAME>GESBaseXmlFormatter</NAME>
struct _GESBaseXmlFormatter
{
  GESFormatter parent;

  /*< public > */
  /* <private> */
  GESBaseXmlFormatterPrivate *priv;

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESBaseXmlFormatterClass</NAME>
struct _GESBaseXmlFormatterClass
{
  GESFormatterClass parent;

  /* Should be overriden by subclasses */
  GMarkupParser content_parser;

  GString * (*save) (GESFormatter *formatter, GESTimeline *timeline, GError **error);

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_base_xml_formatter_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESBaseXmlFormatterPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_CLIP_ASSET</NAME>
#define GES_TYPE_CLIP_ASSET (ges_clip_asset_get_type ())
</MACRO>
<MACRO>
<NAME>GES_CLIP_ASSET</NAME>
#define GES_CLIP_ASSET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_CLIP_ASSET, GESClipAsset))
</MACRO>
<MACRO>
<NAME>GES_CLIP_ASSET_CLASS</NAME>
#define GES_CLIP_ASSET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_CLIP_ASSET, GESClipAssetClass))
</MACRO>
<MACRO>
<NAME>GES_IS_CLIP_ASSET</NAME>
#define GES_IS_CLIP_ASSET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_CLIP_ASSET))
</MACRO>
<MACRO>
<NAME>GES_IS_CLIP_ASSET_CLASS</NAME>
#define GES_IS_CLIP_ASSET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_CLIP_ASSET))
</MACRO>
<MACRO>
<NAME>GES_CLIP_ASSET_GET_CLASS</NAME>
#define GES_CLIP_ASSET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_CLIP_ASSET, GESClipAssetClass))
</MACRO>
<STRUCT>
<NAME>GESClipAsset</NAME>
struct _GESClipAsset
{
  GESAsset parent;

  /* <private> */
  GESClipAssetPrivate *priv;

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESClipAssetClass</NAME>
struct _GESClipAssetClass
{
  GESAssetClass parent;

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_clip_asset_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_asset_set_supported_formats</NAME>
<RETURNS>void  </RETURNS>
GESClipAsset *self, GESTrackType supportedformats
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_asset_get_supported_formats</NAME>
<RETURNS>GESTrackType  </RETURNS>
GESClipAsset *self
</FUNCTION>
<STRUCT>
<NAME>GESClipAssetPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_CLIP</NAME>
#define GES_TYPE_CLIP             ges_clip_get_type()
</MACRO>
<MACRO>
<NAME>GES_CLIP</NAME>
#define GES_CLIP(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_CLIP, GESClip))
</MACRO>
<MACRO>
<NAME>GES_CLIP_CLASS</NAME>
#define GES_CLIP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_CLIP, GESClipClass))
</MACRO>
<MACRO>
<NAME>GES_IS_CLIP</NAME>
#define GES_IS_CLIP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_CLIP))
</MACRO>
<MACRO>
<NAME>GES_IS_CLIP_CLASS</NAME>
#define GES_IS_CLIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_CLIP))
</MACRO>
<MACRO>
<NAME>GES_CLIP_GET_CLASS</NAME>
#define GES_CLIP_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_CLIP, GESClipClass))
</MACRO>
<USER_FUNCTION>
<NAME>GESFillTrackElementFunc</NAME>
<RETURNS>gboolean </RETURNS>
GESClip *clip, GESTrackElement *track_element,
                                             GstElement *nleobj
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GESCreateTrackElementFunc</NAME>
<RETURNS>GESTrackElement *</RETURNS>
GESClip * clip, GESTrackType type
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GESCreateTrackElementsFunc</NAME>
<RETURNS>GList *</RETURNS>
GESClip * clip, GESTrackType type
</USER_FUNCTION>
<STRUCT>
<NAME>GESClip</NAME>
struct _GESClip
{
  GESContainer    parent;

  /*< private >*/
  GESClipPrivate *priv;

  /* Padding for API extension */
  gpointer       _ges_reserved[GES_PADDING_LARGE];
};
</STRUCT>
<STRUCT>
<NAME>GESClipClass</NAME>
struct _GESClipClass
{
  /*< private > */
  GESContainerClass          parent_class;

  /*< public > */
  GESCreateTrackElementFunc  create_track_element;
  GESCreateTrackElementsFunc create_track_elements;

  /*< private >*/
  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING_LARGE];
};
</STRUCT>
<FUNCTION>
<NAME>ges_clip_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_get_supported_formats</NAME>
<RETURNS>GESTrackType       </RETURNS>
GESClip *clip
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_set_supported_formats</NAME>
<RETURNS>void               </RETURNS>
GESClip *clip, GESTrackType       supportedformats
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_add_asset</NAME>
<RETURNS>GESTrackElement *  </RETURNS>
GESClip *clip, GESAsset *asset
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_find_track_element</NAME>
<RETURNS>GESTrackElement *  </RETURNS>
GESClip *clip, GESTrack *track, GType type
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_find_track_elements</NAME>
<RETURNS>GList  *           </RETURNS>
GESClip * clip, GESTrack * track, GESTrackType track_type, GType type
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_get_layer</NAME>
<RETURNS>GESLayer * </RETURNS>
GESClip *clip
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_move_to_layer</NAME>
<RETURNS>gboolean   </RETURNS>
GESClip *clip, GESLayer  *layer
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_get_top_effects</NAME>
<RETURNS>GList *   </RETURNS>
GESClip *clip
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_get_top_effect_position</NAME>
<RETURNS>gint      </RETURNS>
GESClip *clip, GESBaseEffect *effect
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_get_top_effect_index</NAME>
<RETURNS>gint      </RETURNS>
GESClip *clip, GESBaseEffect *effect
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_set_top_effect_priority</NAME>
<RETURNS>gboolean  </RETURNS>
GESClip *clip, GESBaseEffect *effect, guint newpriority
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_set_top_effect_index</NAME>
<RETURNS>gboolean  </RETURNS>
GESClip *clip, GESBaseEffect *effect, guint newindex
</FUNCTION>
<FUNCTION>
<NAME>ges_clip_split</NAME>
<RETURNS>GESClip * </RETURNS>
GESClip *clip, guint64  position
</FUNCTION>
<STRUCT>
<NAME>GESClipPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_COMMAND_LINE_FORMATTER</NAME>
#define GES_TYPE_COMMAND_LINE_FORMATTER             (ges_command_line_formatter_get_type ())
</MACRO>
<MACRO>
<NAME>GES_COMMAND_LINE_FORMATTER</NAME>
#define GES_COMMAND_LINE_FORMATTER(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_COMMAND_LINE_FORMATTER, GESCommandLineFormatter))
</MACRO>
<MACRO>
<NAME>GES_COMMAND_LINE_FORMATTER_CLASS</NAME>
#define GES_COMMAND_LINE_FORMATTER_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_COMMAND_LINE_FORMATTER, GESCommandLineFormatterClass))
</MACRO>
<MACRO>
<NAME>GES_IS_COMMAND_LINE_FORMATTER</NAME>
#define GES_IS_COMMAND_LINE_FORMATTER(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_COMMAND_LINE_FORMATTER))
</MACRO>
<MACRO>
<NAME>GES_IS_COMMAND_LINE_FORMATTER_CLASS</NAME>
#define GES_IS_COMMAND_LINE_FORMATTER_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_COMMAND_LINE_FORMATTER))
</MACRO>
<MACRO>
<NAME>GES_COMMAND_LINE_FORMATTER_GET_CLASS</NAME>
#define GES_COMMAND_LINE_FORMATTER_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_COMMAND_LINE_FORMATTER, GESCommandLineFormatterClass))
</MACRO>
<STRUCT>
<NAME>GESCommandLineFormatterClass</NAME>
struct _GESCommandLineFormatterClass
{
    GESFormatterClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GESCommandLineFormatter</NAME>
struct _GESCommandLineFormatter
{
    GESFormatter parent_instance;

    GESCommandLineFormatterPrivate *priv;
};
</STRUCT>
<FUNCTION>
<NAME>ges_command_line_formatter_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_command_line_formatter_get_help</NAME>
<RETURNS>gchar  * </RETURNS>
gint nargs, gchar ** commands
</FUNCTION>
<STRUCT>
<NAME>GESCommandLineFormatterPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_CONTAINER</NAME>
#define GES_TYPE_CONTAINER             ges_container_get_type()
</MACRO>
<MACRO>
<NAME>GES_CONTAINER</NAME>
#define GES_CONTAINER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_CONTAINER, GESContainer))
</MACRO>
<MACRO>
<NAME>GES_CONTAINER_CLASS</NAME>
#define GES_CONTAINER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_CONTAINER, GESContainerClass))
</MACRO>
<MACRO>
<NAME>GES_IS_CONTAINER</NAME>
#define GES_IS_CONTAINER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_CONTAINER))
</MACRO>
<MACRO>
<NAME>GES_IS_CONTAINER_CLASS</NAME>
#define GES_IS_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_CONTAINER))
</MACRO>
<MACRO>
<NAME>GES_CONTAINER_GET_CLASS</NAME>
#define GES_CONTAINER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_CONTAINER, GESContainerClass))
</MACRO>
<ENUM>
<NAME>GESChildrenControlMode</NAME>
typedef enum
{
  GES_CHILDREN_UPDATE,
  GES_CHILDREN_IGNORE_NOTIFIES,
  GES_CHILDREN_UPDATE_OFFSETS,
  GES_CHILDREN_UPDATE_ALL_VALUES,
  GES_CHILDREN_LAST
} GESChildrenControlMode;
</ENUM>
<MACRO>
<NAME>GES_CONTAINER_HEIGHT</NAME>
#define GES_CONTAINER_HEIGHT(obj) (((GESContainer*)obj)->height)
</MACRO>
<MACRO>
<NAME>GES_CONTAINER_CHILDREN</NAME>
#define GES_CONTAINER_CHILDREN(obj) (((GESContainer*)obj)->children)
</MACRO>
<STRUCT>
<NAME>GESContainer</NAME>
struct _GESContainer
{
  GESTimelineElement parent;

  /*< public > */
  /*< readonly >*/
  GList *children;

  /* We don't add those properties to the priv struct for optimization and code
   * readability purposes */
  guint32 height;       /* the span of priorities this object needs */

  /* <protected> */
  GESChildrenControlMode children_control_mode;
  /*< readonly >*/
  GESTimelineElement *initiated_move;

  /*< private >*/
  GESContainerPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING_LARGE];
};
</STRUCT>
<STRUCT>
<NAME>GESContainerClass</NAME>
struct _GESContainerClass
{
  /*< private > */
  GESTimelineElementClass parent_class;

  /*< public > */
  /* signals */
  void (*child_added)             (GESContainer *container, GESTimelineElement *element);
  void (*child_removed)           (GESContainer *container, GESTimelineElement *element);
  gboolean (*add_child)           (GESContainer *container, GESTimelineElement *element);
  gboolean (*remove_child)        (GESContainer *container, GESTimelineElement *element);
  GList* (*ungroup)               (GESContainer *container, gboolean recursive);
  GESContainer * (*group)         (GList *containers);
  gboolean (*edit)                (GESContainer * container,
                                   GList * layers, gint new_layer_priority,
                                   GESEditMode mode,
                                   GESEdge edge,
                                   guint64 position);



  /*< private >*/
  guint grouping_priority;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING_LARGE];
};
</STRUCT>
<FUNCTION>
<NAME>ges_container_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_container_get_children</NAME>
<RETURNS>GList * </RETURNS>
GESContainer *container, gboolean recursive
</FUNCTION>
<FUNCTION>
<NAME>ges_container_add</NAME>
<RETURNS>gboolean  </RETURNS>
GESContainer *container, GESTimelineElement *child
</FUNCTION>
<FUNCTION>
<NAME>ges_container_remove</NAME>
<RETURNS>gboolean  </RETURNS>
GESContainer *container, GESTimelineElement *child
</FUNCTION>
<FUNCTION>
<NAME>ges_container_ungroup</NAME>
<RETURNS>GList  * </RETURNS>
GESContainer * container, gboolean recursive
</FUNCTION>
<FUNCTION>
<NAME>ges_container_group</NAME>
<RETURNS>GESContainer  *</RETURNS>
GList *containers
</FUNCTION>
<FUNCTION>
<NAME>ges_container_edit</NAME>
<RETURNS>gboolean  </RETURNS>
GESContainer * container, GList * layers, gint new_layer_priority, GESEditMode mode, GESEdge edge, guint64 position
</FUNCTION>
<STRUCT>
<NAME>GESContainerPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_EFFECT_ASSET</NAME>
#define GES_TYPE_EFFECT_ASSET             (ges_effect_asset_get_type ())
</MACRO>
<MACRO>
<NAME>GES_EFFECT_ASSET</NAME>
#define GES_EFFECT_ASSET(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_EFFECT_ASSET, GESEffectAsset))
</MACRO>
<MACRO>
<NAME>GES_EFFECT_ASSET_CLASS</NAME>
#define GES_EFFECT_ASSET_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_EFFECT_ASSET, GESEffectAssetClass))
</MACRO>
<MACRO>
<NAME>GES_IS_EFFECT_ASSET</NAME>
#define GES_IS_EFFECT_ASSET(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_EFFECT_ASSET))
</MACRO>
<MACRO>
<NAME>GES_IS_EFFECT_ASSET_CLASS</NAME>
#define GES_IS_EFFECT_ASSET_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_EFFECT_ASSET))
</MACRO>
<MACRO>
<NAME>GES_EFFECT_ASSET_GET_CLASS</NAME>
#define GES_EFFECT_ASSET_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_EFFECT_ASSET, GESEffectAssetClass))
</MACRO>
<STRUCT>
<NAME>GESEffectAssetClass</NAME>
struct _GESEffectAssetClass
{
  GESTrackElementAssetClass parent_class;

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESEffectAsset</NAME>
struct _GESEffectAsset
{
  GESTrackElementAsset parent_instance;

  GESEffectAssetPrivate *priv;

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_effect_asset_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESEffectAssetPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_EFFECT_CLIP</NAME>
#define GES_TYPE_EFFECT_CLIP ges_effect_clip_get_type()
</MACRO>
<MACRO>
<NAME>GES_EFFECT_CLIP</NAME>
#define GES_EFFECT_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_EFFECT_CLIP, GESEffectClip))
</MACRO>
<MACRO>
<NAME>GES_EFFECT_CLIP_CLASS</NAME>
#define GES_EFFECT_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_EFFECT_CLIP, GESEffectClipClass))
</MACRO>
<MACRO>
<NAME>GES_IS_EFFECT_CLIP</NAME>
#define GES_IS_EFFECT_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_EFFECT_CLIP))
</MACRO>
<MACRO>
<NAME>GES_IS_EFFECT_CLIP_CLASS</NAME>
#define GES_IS_EFFECT_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_EFFECT_CLIP))
</MACRO>
<MACRO>
<NAME>GES_EFFECT_CLIP_GET_CLASS</NAME>
#define GES_EFFECT_CLIP_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_EFFECT_CLIP, GESEffectClipClass))
</MACRO>
<STRUCT>
<NAME>GESEffectClip</NAME>
struct _GESEffectClip {
  /*< private >*/
  GESBaseEffectClip parent;

  GESEffectClipPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESEffectClipClass</NAME>
struct _GESEffectClipClass {
  /*< private >*/
  GESBaseEffectClipClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_effect_clip_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESEffectClipPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_EFFECT</NAME>
#define GES_TYPE_EFFECT ges_effect_get_type()
</MACRO>
<MACRO>
<NAME>GES_EFFECT</NAME>
#define GES_EFFECT(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_EFFECT, GESEffect))
</MACRO>
<MACRO>
<NAME>GES_EFFECT_CLASS</NAME>
#define GES_EFFECT_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_EFFECT, GESEffectClass))
</MACRO>
<MACRO>
<NAME>GES_IS_EFFECT</NAME>
#define GES_IS_EFFECT(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_EFFECT))
</MACRO>
<MACRO>
<NAME>GES_IS_EFFECT_CLASS</NAME>
#define GES_IS_EFFECT_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_EFFECT))
</MACRO>
<MACRO>
<NAME>GES_EFFECT_GET_CLASS</NAME>
#define GES_EFFECT_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_EFFECT, GESEffectClass))
</MACRO>
<STRUCT>
<NAME>GESEffect</NAME>
struct _GESEffect
{
  /*< private > */
  GESBaseEffect parent;
  GESEffectPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESEffectClass</NAME>
struct _GESEffectClass
{
  /*< private > */
  GESBaseEffectClass parent_class;

  GList *rate_properties;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];

};
</STRUCT>
<FUNCTION>
<NAME>ges_effect_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESEffectPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_TRACK_TYPE</NAME>
#define GES_TYPE_TRACK_TYPE (ges_track_type_get_type ())
</MACRO>
<FUNCTION>
<NAME>ges_track_type_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>GESTrackType</NAME>
typedef enum {
  GES_TRACK_TYPE_UNKNOWN = 1 << 0,
  GES_TRACK_TYPE_AUDIO   = 1 << 1,
  GES_TRACK_TYPE_VIDEO   = 1 << 2,
  GES_TRACK_TYPE_TEXT    = 1 << 3,
  GES_TRACK_TYPE_CUSTOM  = 1 << 4,
} GESTrackType;
</ENUM>
<MACRO>
<NAME>GES_META_FLAG_TYPE</NAME>
#define GES_META_FLAG_TYPE (ges_meta_flag_get_type ())
</MACRO>
<FUNCTION>
<NAME>ges_meta_flag_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>GESMetaFlag</NAME>
typedef enum {
  GES_META_READABLE  = 1 << 0,
  GES_META_WRITABLE = 1 << 1,
  GES_META_READ_WRITE = GES_META_READABLE | GES_META_WRITABLE
} GESMetaFlag;
</ENUM>
<ENUM>
<NAME>GESVideoStandardTransitionType</NAME>
typedef enum {
  GES_VIDEO_STANDARD_TRANSITION_TYPE_NONE = 0,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_LR = 1,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_TB = 2,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TL = 3,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TR = 4,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BR = 5,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BL = 6,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CI = 7,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CO = 8,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_V = 21,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_H = 22,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TC = 23,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_RC = 24,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BC = 25,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_LC = 26,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TL = 41,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TR = 42,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_V = 43,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_H = 44,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DBL = 45,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DTL = 46,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DBD = 47,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DD = 48,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_D = 61,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_L = 62,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_U = 63,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_R = 64,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_D = 65,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_L = 66,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_U = 67,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_R = 68,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_IRIS_RECT = 101,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW12 = 201,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW3 = 202,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW6 = 203,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW9 = 204,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBV = 205,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBH = 206,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_FB = 207,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CT = 211,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CR = 212,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOV = 213,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOH = 214,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWT = 221,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWR = 222,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWB = 223,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWL = 224,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PV = 225,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PD = 226,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OV = 227,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OH = 228,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_T = 231,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_R = 232,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_B = 233,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_L = 234,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIV = 235,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIH = 236,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTL = 241,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBL = 242,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBR = 243,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTR = 244,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDTL = 245,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDBL = 246,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_T = 251,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_L = 252,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_B = 253,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_R = 254,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_R = 261,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_U = 262,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_V = 263,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_H = 264,
  GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE = 512
} GESVideoStandardTransitionType;
</ENUM>
<MACRO>
<NAME>GES_VIDEO_STANDARD_TRANSITION_TYPE_TYPE</NAME>
#define GES_VIDEO_STANDARD_TRANSITION_TYPE_TYPE \
    (ges_video_standard_transition_type_get_type())
</MACRO>
<FUNCTION>
<NAME>ges_video_standard_transition_type_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>GESTextVAlign</NAME>
typedef enum {
    GES_TEXT_VALIGN_BASELINE,
    GES_TEXT_VALIGN_BOTTOM,
    GES_TEXT_VALIGN_TOP,
    GES_TEXT_VALIGN_POSITION,
    GES_TEXT_VALIGN_CENTER,
    GES_TEXT_VALIGN_ABSOLUTE
} GESTextVAlign;
</ENUM>
<MACRO>
<NAME>DEFAULT_VALIGNMENT</NAME>
#define DEFAULT_VALIGNMENT GES_TEXT_VALIGN_BASELINE
</MACRO>
<MACRO>
<NAME>GES_TEXT_VALIGN_TYPE</NAME>
#define GES_TEXT_VALIGN_TYPE\
  (ges_text_valign_get_type ())
</MACRO>
<FUNCTION>
<NAME>ges_text_valign_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>GESTextHAlign</NAME>
typedef enum {
    GES_TEXT_HALIGN_LEFT = 0,
    GES_TEXT_HALIGN_CENTER = 1,
    GES_TEXT_HALIGN_RIGHT = 2,
    GES_TEXT_HALIGN_POSITION = 4,
    GES_TEXT_HALIGN_ABSOLUTE = 5
} GESTextHAlign;
</ENUM>
<MACRO>
<NAME>DEFAULT_HALIGNMENT</NAME>
#define DEFAULT_HALIGNMENT GES_TEXT_HALIGN_CENTER
</MACRO>
<MACRO>
<NAME>GES_TEXT_HALIGN_TYPE</NAME>
#define GES_TEXT_HALIGN_TYPE\
  (ges_text_halign_get_type ())
</MACRO>
<FUNCTION>
<NAME>ges_text_halign_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>GESVideoTestPattern</NAME>
typedef enum {
  GES_VIDEO_TEST_PATTERN_SMPTE,
  GES_VIDEO_TEST_PATTERN_SNOW,
  GES_VIDEO_TEST_PATTERN_BLACK,
  GES_VIDEO_TEST_PATTERN_WHITE,
  GES_VIDEO_TEST_PATTERN_RED,
  GES_VIDEO_TEST_PATTERN_GREEN,
  GES_VIDEO_TEST_PATTERN_BLUE,
  GES_VIDEO_TEST_PATTERN_CHECKERS1,
  GES_VIDEO_TEST_PATTERN_CHECKERS2,
  GES_VIDEO_TEST_PATTERN_CHECKERS4,
  GES_VIDEO_TEST_PATTERN_CHECKERS8,
  GES_VIDEO_TEST_PATTERN_CIRCULAR,
  GES_VIDEO_TEST_PATTERN_BLINK,
  GES_VIDEO_TEST_PATTERN_SMPTE75,
  GES_VIDEO_TEST_ZONE_PLATE,
  GES_VIDEO_TEST_GAMUT,
  GES_VIDEO_TEST_CHROMA_ZONE_PLATE,
  GES_VIDEO_TEST_PATTERN_SOLID,
} GESVideoTestPattern;
</ENUM>
<MACRO>
<NAME>GES_VIDEO_TEST_PATTERN_TYPE</NAME>
#define GES_VIDEO_TEST_PATTERN_TYPE\
  ges_video_test_pattern_get_type()
</MACRO>
<FUNCTION>
<NAME>ges_video_test_pattern_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>GESPipelineFlags</NAME>
typedef enum {
  GES_PIPELINE_MODE_PREVIEW_AUDIO	= 1 << 0,
  GES_PIPELINE_MODE_PREVIEW_VIDEO	= 1 << 1,
  GES_PIPELINE_MODE_PREVIEW		= GES_PIPELINE_MODE_PREVIEW_AUDIO | GES_PIPELINE_MODE_PREVIEW_VIDEO,
  GES_PIPELINE_MODE_RENDER		= 1 << 2,
  GES_PIPELINE_MODE_SMART_RENDER	= 1 << 3
} GESPipelineFlags;
</ENUM>
<MACRO>
<NAME>GES_TYPE_PIPELINE_FLAGS</NAME>
#define GES_TYPE_PIPELINE_FLAGS\
  ges_pipeline_flags_get_type()
</MACRO>
<FUNCTION>
<NAME>ges_pipeline_flags_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>GESEditMode</NAME>
typedef enum {
    GES_EDIT_MODE_NORMAL,
    GES_EDIT_MODE_RIPPLE,
    GES_EDIT_MODE_ROLL,
    GES_EDIT_MODE_TRIM,
    GES_EDIT_MODE_SLIDE
} GESEditMode;
</ENUM>
<MACRO>
<NAME>GES_TYPE_EDIT_MODE</NAME>
#define GES_TYPE_EDIT_MODE ges_edit_mode_get_type()
</MACRO>
<FUNCTION>
<NAME>ges_edit_mode_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>GESEdge</NAME>
typedef enum {
    GES_EDGE_START,
    GES_EDGE_END,
    GES_EDGE_NONE
} GESEdge;
</ENUM>
<FUNCTION>
<NAME>ges_edge_name</NAME>
<RETURNS>const gchar  * </RETURNS>
GESEdge edge
</FUNCTION>
<MACRO>
<NAME>GES_TYPE_EDGE</NAME>
#define GES_TYPE_EDGE ges_edge_get_type()
</MACRO>
<FUNCTION>
<NAME>ges_edge_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_track_type_name</NAME>
<RETURNS>const gchar  * </RETURNS>
GESTrackType type
</FUNCTION>
<MACRO>
<NAME>GES_TYPE_EXTRACTABLE</NAME>
#define GES_TYPE_EXTRACTABLE                (ges_extractable_get_type ())
</MACRO>
<MACRO>
<NAME>GES_EXTRACTABLE</NAME>
#define GES_EXTRACTABLE(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_EXTRACTABLE, GESExtractable))
</MACRO>
<MACRO>
<NAME>GES_IS_EXTRACTABLE</NAME>
#define GES_IS_EXTRACTABLE(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_EXTRACTABLE))
</MACRO>
<MACRO>
<NAME>GES_EXTRACTABLE_GET_INTERFACE</NAME>
#define GES_EXTRACTABLE_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GES_TYPE_EXTRACTABLE, GESExtractableInterface))
</MACRO>
<FUNCTION>
<NAME>ges_extractable_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<USER_FUNCTION>
<NAME>GESExtractableCheckId</NAME>
<RETURNS>gchar *</RETURNS>
GType type, const gchar *id,
    GError **error
</USER_FUNCTION>
<STRUCT>
<NAME>GESExtractableInterface</NAME>
struct _GESExtractableInterface
{
  GTypeInterface parent;

  GType asset_type;

  GESExtractableCheckId check_id;
  gboolean can_update_asset;

  void (*set_asset)                  (GESExtractable *self,
                                         GESAsset *asset);

  gboolean (*set_asset_full)         (GESExtractable *self,
                                      GESAsset *asset);

  GParameter *(*get_parameters_from_id) (const gchar *id,
                                         guint *n_params);

  gchar * (*get_id)                     (GESExtractable *self);

  GType (*get_real_extractable_type)    (GType wanted_type,
                                         const gchar *id);

  gboolean (*register_metas)            (GESExtractableInterface *self,
                                         GObjectClass *klass,
                                         GESAsset *asset);

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_extractable_get_asset</NAME>
<RETURNS>GESAsset * </RETURNS>
GESExtractable *self
</FUNCTION>
<FUNCTION>
<NAME>ges_extractable_set_asset</NAME>
<RETURNS>gboolean  </RETURNS>
GESExtractable *self, GESAsset *asset
</FUNCTION>
<FUNCTION>
<NAME>ges_extractable_get_id</NAME>
<RETURNS>gchar  * </RETURNS>
GESExtractable *self
</FUNCTION>
<STRUCT>
<NAME>GESExtractable</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_FORMATTER</NAME>
#define GES_TYPE_FORMATTER ges_formatter_get_type()
</MACRO>
<MACRO>
<NAME>GES_FORMATTER</NAME>
#define GES_FORMATTER(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_FORMATTER, GESFormatter))
</MACRO>
<MACRO>
<NAME>GES_FORMATTER_CLASS</NAME>
#define GES_FORMATTER_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_FORMATTER, GESFormatterClass))
</MACRO>
<MACRO>
<NAME>GES_IS_FORMATTER</NAME>
#define GES_IS_FORMATTER(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_FORMATTER))
</MACRO>
<MACRO>
<NAME>GES_IS_FORMATTER_CLASS</NAME>
#define GES_IS_FORMATTER_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_FORMATTER))
</MACRO>
<MACRO>
<NAME>GES_FORMATTER_GET_CLASS</NAME>
#define GES_FORMATTER_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_FORMATTER, GESFormatterClass))
</MACRO>
<STRUCT>
<NAME>GESFormatter</NAME>
struct _GESFormatter {
  GInitiallyUnowned parent;

  /*< private >*/
  GESFormatterPrivate *priv;

  /*< protected >*/
  GESProject *project;
  GESTimeline *timeline;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<USER_FUNCTION>
<NAME>GESFormatterCanLoadURIMethod</NAME>
<RETURNS>gboolean </RETURNS>
GESFormatter *dummy_instance, const gchar * uri, GError **error
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GESFormatterLoadFromURIMethod</NAME>
<RETURNS>gboolean </RETURNS>
GESFormatter *formatter,
                  GESTimeline *timeline,
                  const gchar * uri,
                  GError **error
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GESFormatterSaveToURIMethod</NAME>
<RETURNS>gboolean </RETURNS>
GESFormatter *formatter,
               GESTimeline *timeline, const gchar * uri, gboolean overwrite,
               GError **error
</USER_FUNCTION>
<STRUCT>
<NAME>GESFormatterClass</NAME>
struct _GESFormatterClass {
  GInitiallyUnownedClass parent_class;

  /* TODO 2.0: Rename the loading method to can_load and load.
   * Technically we just pass data to load, it should not necessarily
   * be a URI */
  GESFormatterCanLoadURIMethod can_load_uri;
  GESFormatterLoadFromURIMethod load_from_uri;
  GESFormatterSaveToURIMethod save_to_uri;

  /* < private > */
  const gchar *name;
  const gchar *description;
  const gchar *extension;
  const gchar *mimetype;
  gdouble version;
  GstRank rank;


  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_formatter_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_formatter_class_register_metas</NAME>
<RETURNS>void  </RETURNS>
GESFormatterClass * klass, const gchar *name, const gchar *description, const gchar *extension, const gchar *mimetype, gdouble version, GstRank rank
</FUNCTION>
<FUNCTION>
<NAME>ges_formatter_can_load_uri</NAME>
<RETURNS>gboolean  </RETURNS>
const gchar * uri, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ges_formatter_can_save_uri</NAME>
<RETURNS>gboolean  </RETURNS>
const gchar * uri, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ges_formatter_load_from_uri</NAME>
<RETURNS>gboolean  </RETURNS>
GESFormatter * formatter, GESTimeline  *timeline, const gchar *uri, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ges_formatter_save_to_uri</NAME>
<RETURNS>gboolean  </RETURNS>
GESFormatter * formatter, GESTimeline *timeline, const gchar *uri, gboolean overwrite, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ges_formatter_get_default</NAME>
<RETURNS>GESAsset  *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESFormatterPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_ERROR</NAME>
#define GES_ERROR g_quark_from_static_string("GES_ERROR")
</MACRO>
<ENUM>
<NAME>GESError</NAME>
typedef enum
{
  GES_ERROR_ASSET_WRONG_ID,
  GES_ERROR_ASSET_LOADING,
  GES_ERROR_FORMATTER_MALFORMED_INPUT_FILE,
} GESError;
</ENUM>
<MACRO>
<NAME>GES_TYPE_GROUP</NAME>
#define GES_TYPE_GROUP (ges_group_get_type ())
</MACRO>
<MACRO>
<NAME>GES_GROUP</NAME>
#define GES_GROUP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_GROUP, GESGroup))
</MACRO>
<MACRO>
<NAME>GES_GROUP_CLASS</NAME>
#define GES_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_GROUP, GESGroupClass))
</MACRO>
<MACRO>
<NAME>GES_IS_GROUP</NAME>
#define GES_IS_GROUP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_GROUP))
</MACRO>
<MACRO>
<NAME>GES_IS_GROUP_CLASS</NAME>
#define GES_IS_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_GROUP))
</MACRO>
<MACRO>
<NAME>GES_GROUP_GET_CLASS</NAME>
#define GES_GROUP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_GROUP, GESGroupClass))
</MACRO>
<STRUCT>
<NAME>GESGroup</NAME>
struct _GESGroup {
  GESContainer parent;

  /*< private >*/
  GESGroupPrivate *priv;

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESGroupClass</NAME>
struct _GESGroupClass {
  GESContainerClass parent_class;

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_group_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_group_new</NAME>
<RETURNS>GESGroup  *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESGroupPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_IMAGE_SOURCE</NAME>
#define GES_TYPE_IMAGE_SOURCE ges_image_source_get_type()
</MACRO>
<MACRO>
<NAME>GES_IMAGE_SOURCE</NAME>
#define GES_IMAGE_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_IMAGE_SOURCE, GESImageSource))
</MACRO>
<MACRO>
<NAME>GES_IMAGE_SOURCE_CLASS</NAME>
#define GES_IMAGE_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_IMAGE_SOURCE, GESImageSourceClass))
</MACRO>
<MACRO>
<NAME>GES_IS_IMAGE_SOURCE</NAME>
#define GES_IS_IMAGE_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_IMAGE_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_IS_IMAGE_SOURCE_CLASS</NAME>
#define GES_IS_IMAGE_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_IMAGE_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_IMAGE_SOURCE_GET_CLASS</NAME>
#define GES_IMAGE_SOURCE_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_IMAGE_SOURCE, GESImageSourceClass))
</MACRO>
<STRUCT>
<NAME>GESImageSource</NAME>
struct _GESImageSource {
  /*< private >*/
  GESVideoSource parent;

  gchar *uri;

  GESImageSourcePrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESImageSourceClass</NAME>
struct _GESImageSourceClass {
  GESVideoSourceClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_image_source_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESImageSourcePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_LAYER</NAME>
#define GES_TYPE_LAYER ges_layer_get_type()
</MACRO>
<MACRO>
<NAME>GES_LAYER</NAME>
#define GES_LAYER(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_LAYER, GESLayer))
</MACRO>
<MACRO>
<NAME>GES_LAYER_CLASS</NAME>
#define GES_LAYER_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_LAYER, GESLayerClass))
</MACRO>
<MACRO>
<NAME>GES_IS_LAYER</NAME>
#define GES_IS_LAYER(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_LAYER))
</MACRO>
<MACRO>
<NAME>GES_IS_LAYER_CLASS</NAME>
#define GES_IS_LAYER_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_LAYER))
</MACRO>
<MACRO>
<NAME>GES_LAYER_GET_CLASS</NAME>
#define GES_LAYER_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_LAYER, GESLayerClass))
</MACRO>
<STRUCT>
<NAME>GESLayer</NAME>
struct _GESLayer {
  GInitiallyUnowned parent;

  /*< public >*/

  GESTimeline *timeline;

  /*< protected >*/
  guint32 min_nle_priority, max_nle_priority;

  GESLayerPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESLayerClass</NAME>
struct _GESLayerClass {
  /*< private >*/
  GInitiallyUnownedClass parent_class;

  /*< public >*/
  /* virtual methods for subclasses */
  GList *(*get_objects) (GESLayer * layer);

  /*< private >*/
  /* Signals */
  void	(*object_added)		(GESLayer * layer, GESClip * object);
  void	(*object_removed)	(GESLayer * layer, GESClip * object);

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_layer_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_layer_new</NAME>
<RETURNS>GESLayer * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_layer_set_timeline</NAME>
<RETURNS>void      </RETURNS>
GESLayer * layer, GESTimeline * timeline
</FUNCTION>
<FUNCTION>
<NAME>ges_layer_add_clip</NAME>
<RETURNS>gboolean  </RETURNS>
GESLayer * layer, GESClip * clip
</FUNCTION>
<FUNCTION>
<NAME>ges_layer_add_asset</NAME>
<RETURNS>GESClip  * </RETURNS>
GESLayer *layer, GESAsset *asset, GstClockTime start, GstClockTime inpoint, GstClockTime duration, GESTrackType track_types
</FUNCTION>
<FUNCTION>
<NAME>ges_layer_remove_clip</NAME>
<RETURNS>gboolean  </RETURNS>
GESLayer * layer, GESClip * clip
</FUNCTION>
<FUNCTION>
<NAME>ges_layer_set_priority</NAME>
<RETURNS>void      </RETURNS>
GESLayer * layer, guint priority
</FUNCTION>
<FUNCTION>
<NAME>ges_layer_is_empty</NAME>
<RETURNS>gboolean  </RETURNS>
GESLayer * layer
</FUNCTION>
<FUNCTION>
<NAME>ges_layer_get_clips_in_interval</NAME>
<RETURNS>GList * </RETURNS>
GESLayer * layer, GstClockTime start, GstClockTime end
</FUNCTION>
<FUNCTION>
<NAME>ges_layer_get_priority</NAME>
<RETURNS>guint    </RETURNS>
GESLayer * layer
</FUNCTION>
<FUNCTION>
<NAME>ges_layer_get_auto_transition</NAME>
<RETURNS>gboolean  </RETURNS>
GESLayer * layer
</FUNCTION>
<FUNCTION>
<NAME>ges_layer_set_auto_transition</NAME>
<RETURNS>void  </RETURNS>
GESLayer * layer, gboolean auto_transition
</FUNCTION>
<FUNCTION>
<NAME>ges_layer_get_clips</NAME>
<RETURNS>GList *   </RETURNS>
GESLayer * layer
</FUNCTION>
<FUNCTION>
<NAME>ges_layer_get_duration</NAME>
<RETURNS>GstClockTime  </RETURNS>
GESLayer *layer
</FUNCTION>
<STRUCT>
<NAME>GESLayerPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_META_CONTAINER</NAME>
#define GES_TYPE_META_CONTAINER                 (ges_meta_container_get_type ())
</MACRO>
<MACRO>
<NAME>GES_META_CONTAINER</NAME>
#define GES_META_CONTAINER(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_META_CONTAINER, GESMetaContainer))
</MACRO>
<MACRO>
<NAME>GES_IS_META_CONTAINER</NAME>
#define GES_IS_META_CONTAINER(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_META_CONTAINER))
</MACRO>
<MACRO>
<NAME>GES_META_CONTAINER_GET_INTERFACE</NAME>
#define GES_META_CONTAINER_GET_INTERFACE (inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GES_TYPE_META_CONTAINER, GESMetaContainerInterface))
</MACRO>
<MACRO>
<NAME>GES_META_FORMATTER_NAME</NAME>
#define GES_META_FORMATTER_NAME                       "name"
</MACRO>
<MACRO>
<NAME>GES_META_DESCRIPTION</NAME>
#define GES_META_DESCRIPTION                         "description"
</MACRO>
<MACRO>
<NAME>GES_META_FORMATTER_MIMETYPE</NAME>
#define GES_META_FORMATTER_MIMETYPE                   "mimetype"
</MACRO>
<MACRO>
<NAME>GES_META_FORMATTER_EXTENSION</NAME>
#define GES_META_FORMATTER_EXTENSION                  "extension"
</MACRO>
<MACRO>
<NAME>GES_META_FORMATTER_VERSION</NAME>
#define GES_META_FORMATTER_VERSION                    "version"
</MACRO>
<MACRO>
<NAME>GES_META_FORMATTER_RANK</NAME>
#define GES_META_FORMATTER_RANK                       "rank"
</MACRO>
<MACRO>
<NAME>GES_META_VOLUME</NAME>
#define GES_META_VOLUME                              "volume"
</MACRO>
<MACRO>
<NAME>GES_META_VOLUME_DEFAULT</NAME>
#define GES_META_VOLUME_DEFAULT                       1.0
</MACRO>
<MACRO>
<NAME>GES_META_FORMAT_VERSION</NAME>
#define GES_META_FORMAT_VERSION                       "format-version"
</MACRO>
<STRUCT>
<NAME>GESMetaContainerInterface</NAME>
struct _GESMetaContainerInterface {
  GTypeInterface parent_iface;

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_meta_container_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<USER_FUNCTION>
<NAME>GESMetaForeachFunc</NAME>
<RETURNS>void </RETURNS>
const GESMetaContainer *container,
                                        const gchar *key,
                                        const GValue *value,
                                        gpointer user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GESMetaContainer</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_MULTI_FILE_SOURCE</NAME>
#define GES_TYPE_MULTI_FILE_SOURCE ges_multi_file_source_get_type()
</MACRO>
<MACRO>
<NAME>GES_MULTI_FILE_SOURCE</NAME>
#define GES_MULTI_FILE_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_MULTI_FILE_SOURCE, GESMultiFileSource))
</MACRO>
<MACRO>
<NAME>GES_MULTI_FILE_SOURCE_CLASS</NAME>
#define GES_MULTI_FILE_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_MULTI_FILE_SOURCE, GESMultiFileSourceClass))
</MACRO>
<MACRO>
<NAME>GES_IS_MULTI_FILE_SOURCE</NAME>
#define GES_IS_MULTI_FILE_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_MULTI_FILE_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_IS_MULTI_FILE_SOURCE_CLASS</NAME>
#define GES_IS_MULTI_FILE_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_MULTI_FILE_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_MULTI_FILE_SOURCE_GET_CLASS</NAME>
#define GES_MULTI_FILE_SOURCE_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_MULTI_FILE_SOURCE, GESMultiFileSourceClass))
</MACRO>
<STRUCT>
<NAME>GESMultiFileSource</NAME>
struct _GESMultiFileSource
{
  /*< private > */
  GESVideoSource parent;

  gchar *uri;

  GESMultiFileSourcePrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESMultiFileSourceClass</NAME>
struct _GESMultiFileSourceClass
{
  GESVideoSourceClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_multi_file_source_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_multi_file_source_new</NAME>
<RETURNS>GESMultiFileSource  *</RETURNS>
gchar * uri
</FUNCTION>
<MACRO>
<NAME>GES_MULTI_FILE_URI_PREFIX</NAME>
#define GES_MULTI_FILE_URI_PREFIX "multifile://"
</MACRO>
<STRUCT>
<NAME>GESMultiFileSourcePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_OPERATION_CLIP</NAME>
#define GES_TYPE_OPERATION_CLIP ges_operation_clip_get_type()
</MACRO>
<MACRO>
<NAME>GES_OPERATION_CLIP</NAME>
#define GES_OPERATION_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_OPERATION_CLIP, GESOperationClip))
</MACRO>
<MACRO>
<NAME>GES_OPERATION_CLIP_CLASS</NAME>
#define GES_OPERATION_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_OPERATION_CLIP, GESOperationClipClass))
</MACRO>
<MACRO>
<NAME>GES_IS_OPERATION_CLIP</NAME>
#define GES_IS_OPERATION_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_OPERATION_CLIP))
</MACRO>
<MACRO>
<NAME>GES_IS_OPERATION_CLIP_CLASS</NAME>
#define GES_IS_OPERATION_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_OPERATION_CLIP))
</MACRO>
<MACRO>
<NAME>GES_OPERATION_CLIP_GET_CLASS</NAME>
#define GES_OPERATION_CLIP_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_OPERATION_CLIP, GESOperationClipClass))
</MACRO>
<STRUCT>
<NAME>GESOperationClip</NAME>
struct _GESOperationClip {
  /*< private >*/
  GESClip parent;

  GESOperationClipPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESOperationClipClass</NAME>
struct _GESOperationClipClass {
  /*< private >*/
  GESClipClass parent_class;

  /*< private >*/
  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_operation_clip_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESOperationClipPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_OPERATION</NAME>
#define GES_TYPE_OPERATION ges_operation_get_type()
</MACRO>
<MACRO>
<NAME>GES_OPERATION</NAME>
#define GES_OPERATION(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_OPERATION, GESOperation))
</MACRO>
<MACRO>
<NAME>GES_OPERATION_CLASS</NAME>
#define GES_OPERATION_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_OPERATION, GESOperationClass))
</MACRO>
<MACRO>
<NAME>GES_IS_OPERATION</NAME>
#define GES_IS_OPERATION(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_OPERATION))
</MACRO>
<MACRO>
<NAME>GES_IS_OPERATION_CLASS</NAME>
#define GES_IS_OPERATION_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_OPERATION))
</MACRO>
<MACRO>
<NAME>GES_OPERATION_GET_CLASS</NAME>
#define GES_OPERATION_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_OPERATION, GESOperationClass))
</MACRO>
<STRUCT>
<NAME>GESOperation</NAME>
struct _GESOperation {
  /*< private >*/
  GESTrackElement parent;

  GESOperationPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESOperationClass</NAME>
struct _GESOperationClass {
  /*< private >*/
  GESTrackElementClass parent_class;

  /*< private >*/
  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_operation_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESOperationPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_OVERLAY_CLIP</NAME>
#define GES_TYPE_OVERLAY_CLIP ges_overlay_clip_get_type()
</MACRO>
<MACRO>
<NAME>GES_OVERLAY_CLIP</NAME>
#define GES_OVERLAY_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_OVERLAY_CLIP, GESOverlayClip))
</MACRO>
<MACRO>
<NAME>GES_OVERLAY_CLIP_CLASS</NAME>
#define GES_OVERLAY_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_OVERLAY_CLIP, GESOverlayClipClass))
</MACRO>
<MACRO>
<NAME>GES_IS_OVERLAY_CLIP</NAME>
#define GES_IS_OVERLAY_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_OVERLAY_CLIP))
</MACRO>
<MACRO>
<NAME>GES_IS_OVERLAY_CLIP_CLASS</NAME>
#define GES_IS_OVERLAY_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_OVERLAY_CLIP))
</MACRO>
<MACRO>
<NAME>GES_OVERLAY_CLIP_GET_CLASS</NAME>
#define GES_OVERLAY_CLIP_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_OVERLAY_CLIP, GESOverlayClipClass))
</MACRO>
<STRUCT>
<NAME>GESOverlayClip</NAME>
struct _GESOverlayClip {
  /*< private >*/
  GESOperationClip parent;

  GESOverlayClipPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESOverlayClipClass</NAME>
struct _GESOverlayClipClass {
  GESOperationClipClass parent_class;

  /*< private >*/
  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_overlay_clip_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESOverlayClipPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>priv_ges_parse_yyIN_HEADER</NAME>
#define priv_ges_parse_yyIN_HEADER 1
</MACRO>
<MACRO>
<NAME>YY_INT_ALIGNED</NAME>
#define  YY_INT_ALIGNED short int
</MACRO>
<MACRO>
<NAME>FLEX_SCANNER</NAME>
#define FLEX_SCANNER
</MACRO>
<MACRO>
<NAME>YY_FLEX_MAJOR_VERSION</NAME>
#define YY_FLEX_MAJOR_VERSION 2
</MACRO>
<MACRO>
<NAME>YY_FLEX_MINOR_VERSION</NAME>
#define YY_FLEX_MINOR_VERSION 6
</MACRO>
<MACRO>
<NAME>YY_FLEX_SUBMINOR_VERSION</NAME>
#define YY_FLEX_SUBMINOR_VERSION 1
</MACRO>
<MACRO>
<NAME>FLEX_BETA</NAME>
#define FLEX_BETA
</MACRO>
<MACRO>
<NAME>FLEXINT_H</NAME>
#define FLEXINT_H
</MACRO>
<TYPEDEF>
<NAME>flex_int8_t</NAME>
typedef int8_t flex_int8_t;
</TYPEDEF>
<TYPEDEF>
<NAME>flex_uint8_t</NAME>
typedef uint8_t flex_uint8_t;
</TYPEDEF>
<TYPEDEF>
<NAME>flex_int16_t</NAME>
typedef int16_t flex_int16_t;
</TYPEDEF>
<TYPEDEF>
<NAME>flex_uint16_t</NAME>
typedef uint16_t flex_uint16_t;
</TYPEDEF>
<TYPEDEF>
<NAME>flex_int32_t</NAME>
typedef int32_t flex_int32_t;
</TYPEDEF>
<TYPEDEF>
<NAME>flex_uint32_t</NAME>
typedef uint32_t flex_uint32_t;
</TYPEDEF>
<MACRO>
<NAME>INT8_MIN</NAME>
#define INT8_MIN               (-128)
</MACRO>
<MACRO>
<NAME>INT16_MIN</NAME>
#define INT16_MIN              (-32767-1)
</MACRO>
<MACRO>
<NAME>INT32_MIN</NAME>
#define INT32_MIN              (-2147483647-1)
</MACRO>
<MACRO>
<NAME>INT8_MAX</NAME>
#define INT8_MAX               (127)
</MACRO>
<MACRO>
<NAME>INT16_MAX</NAME>
#define INT16_MAX              (32767)
</MACRO>
<MACRO>
<NAME>INT32_MAX</NAME>
#define INT32_MAX              (2147483647)
</MACRO>
<MACRO>
<NAME>UINT8_MAX</NAME>
#define UINT8_MAX              (255U)
</MACRO>
<MACRO>
<NAME>UINT16_MAX</NAME>
#define UINT16_MAX             (65535U)
</MACRO>
<MACRO>
<NAME>UINT32_MAX</NAME>
#define UINT32_MAX             (4294967295U)
</MACRO>
<MACRO>
<NAME>yyconst</NAME>
#define yyconst const
</MACRO>
<MACRO>
<NAME>yynoreturn</NAME>
#define yynoreturn __attribute__((__noreturn__))
</MACRO>
<MACRO>
<NAME>YY_TYPEDEF_YY_SCANNER_T</NAME>
#define YY_TYPEDEF_YY_SCANNER_T
</MACRO>
<TYPEDEF>
<NAME>yyscan_t</NAME>
typedef void* yyscan_t;
</TYPEDEF>
<MACRO>
<NAME>yyin</NAME>
#define yyin yyg->yyin_r
</MACRO>
<MACRO>
<NAME>yyout</NAME>
#define yyout yyg->yyout_r
</MACRO>
<MACRO>
<NAME>yyextra</NAME>
#define yyextra yyg->yyextra_r
</MACRO>
<MACRO>
<NAME>yyleng</NAME>
#define yyleng yyg->yyleng_r
</MACRO>
<MACRO>
<NAME>yytext</NAME>
#define yytext yyg->yytext_r
</MACRO>
<MACRO>
<NAME>yylineno</NAME>
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
</MACRO>
<MACRO>
<NAME>yycolumn</NAME>
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
</MACRO>
<MACRO>
<NAME>yy_flex_debug</NAME>
#define yy_flex_debug yyg->yy_flex_debug_r
</MACRO>
<MACRO>
<NAME>YY_BUF_SIZE</NAME>
#define YY_BUF_SIZE 32768
</MACRO>
<MACRO>
<NAME>YY_TYPEDEF_YY_BUFFER_STATE</NAME>
#define YY_TYPEDEF_YY_BUFFER_STATE
</MACRO>
<TYPEDEF>
<NAME>YY_BUFFER_STATE</NAME>
typedef struct yy_buffer_state *YY_BUFFER_STATE;
</TYPEDEF>
<MACRO>
<NAME>YY_TYPEDEF_YY_SIZE_T</NAME>
#define YY_TYPEDEF_YY_SIZE_T
</MACRO>
<TYPEDEF>
<NAME>yy_size_t</NAME>
typedef size_t yy_size_t;
</TYPEDEF>
<MACRO>
<NAME>YY_STRUCT_YY_BUFFER_STATE</NAME>
#define YY_STRUCT_YY_BUFFER_STATE
</MACRO>
<MACRO>
<NAME>GES_TYPE_PIPELINE</NAME>
#define GES_TYPE_PIPELINE ges_pipeline_get_type()
</MACRO>
<MACRO>
<NAME>GES_PIPELINE</NAME>
#define GES_PIPELINE(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_PIPELINE, GESPipeline))
</MACRO>
<MACRO>
<NAME>GES_PIPELINE_CLASS</NAME>
#define GES_PIPELINE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_PIPELINE, GESPipelineClass))
</MACRO>
<MACRO>
<NAME>GES_IS_PIPELINE</NAME>
#define GES_IS_PIPELINE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_PIPELINE))
</MACRO>
<MACRO>
<NAME>GES_IS_PIPELINE_CLASS</NAME>
#define GES_IS_PIPELINE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_PIPELINE))
</MACRO>
<MACRO>
<NAME>GES_PIPELINE_GET_CLASS</NAME>
#define GES_PIPELINE_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_PIPELINE, GESPipelineClass))
</MACRO>
<STRUCT>
<NAME>GESPipeline</NAME>
struct _GESPipeline {
  /*< private >*/
  GstPipeline parent;

  GESPipelinePrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESPipelineClass</NAME>
struct _GESPipelineClass {
  /*< private >*/
  GstPipelineClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_pipeline_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_pipeline_new</NAME>
<RETURNS>GESPipeline * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_pipeline_set_timeline</NAME>
<RETURNS>gboolean  </RETURNS>
GESPipeline * pipeline, GESTimeline * timeline
</FUNCTION>
<FUNCTION>
<NAME>ges_pipeline_set_render_settings</NAME>
<RETURNS>gboolean  </RETURNS>
GESPipeline *pipeline, const gchar * output_uri, GstEncodingProfile *profile
</FUNCTION>
<FUNCTION>
<NAME>ges_pipeline_set_mode</NAME>
<RETURNS>gboolean  </RETURNS>
GESPipeline *pipeline, GESPipelineFlags mode
</FUNCTION>
<FUNCTION>
<NAME>ges_pipeline_get_mode</NAME>
<RETURNS>GESPipelineFlags  </RETURNS>
GESPipeline *pipeline
</FUNCTION>
<STRUCT>
<NAME>GESPipelinePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_PITIVI_FORMATTER</NAME>
#define GES_TYPE_PITIVI_FORMATTER ges_pitivi_formatter_get_type()
</MACRO>
<MACRO>
<NAME>GES_PITIVI_FORMATTER</NAME>
#define GES_PITIVI_FORMATTER(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_PITIVI_FORMATTER, GESPitiviFormatter))
</MACRO>
<MACRO>
<NAME>GES_PITIVI_FORMATTER_CLASS</NAME>
#define GES_PITIVI_FORMATTER_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_PITIVI_FORMATTER, GESPitiviFormatterClass))
</MACRO>
<MACRO>
<NAME>GES_IS_PITIVI_FORMATTER</NAME>
#define GES_IS_PITIVI_FORMATTER(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_PITIVI_FORMATTER))
</MACRO>
<MACRO>
<NAME>GES_IS_PITIVI_FORMATTER_CLASS</NAME>
#define GES_IS_PITIVI_FORMATTER_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_PITIVI_FORMATTER))
</MACRO>
<MACRO>
<NAME>GES_PITIVI_FORMATTER_GET_CLASS</NAME>
#define GES_PITIVI_FORMATTER_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_PITIVI_FORMATTER, GESPitiviFormatterClass))
</MACRO>
<STRUCT>
<NAME>GESPitiviFormatter</NAME>
struct _GESPitiviFormatter {
  GESFormatter parent;

  /*< public > */
  /*< private >*/
  GESPitiviFormatterPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESPitiviFormatterClass</NAME>
struct _GESPitiviFormatterClass
{
  /*< private >*/
  GESFormatterClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_pitivi_formatter_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_pitivi_formatter_new</NAME>
<RETURNS>GESPitiviFormatter  *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESPitiviFormatterPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_API</NAME>
#  define GES_API GST_API_EXPORT         /* from config.h */
</MACRO>
<MACRO>
<NAME>GES_TYPE_PROJECT</NAME>
#define GES_TYPE_PROJECT            ges_project_get_type()
</MACRO>
<MACRO>
<NAME>GES_PROJECT</NAME>
#define GES_PROJECT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_PROJECT, GESProject))
</MACRO>
<MACRO>
<NAME>GES_PROJECT_CLASS</NAME>
#define GES_PROJECT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_PROJECT, GESProjectClass))
</MACRO>
<MACRO>
<NAME>GES_IS_PROJECT</NAME>
#define GES_IS_PROJECT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_PROJECT))
</MACRO>
<MACRO>
<NAME>GES_IS_PROJECT_CLASS</NAME>
#define GES_IS_PROJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_PROJECT))
</MACRO>
<MACRO>
<NAME>GES_PROJECT_GET_CLASS</NAME>
#define GES_PROJECT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_PROJECT, GESProjectClass))
</MACRO>
<FUNCTION>
<NAME>ges_project_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESProject</NAME>
struct _GESProject
{
  GESAsset parent;

  /* <private> */
  GESProjectPrivate *priv;

  /* Padding for API extension */
  gpointer __ges_reserved[GES_PADDING_LARGE];
};
</STRUCT>
<STRUCT>
<NAME>GESProjectClass</NAME>
struct _GESProjectClass
{
  GESAssetClass parent_class;

  /* Signals */
  void     (*asset_added)    (GESProject * self,
                              GESAsset   * asset);
  void     (*asset_loading)  (GESProject * self,
                              GESAsset   * asset);
  void     (*asset_removed)  (GESProject * self,
                              GESAsset   * asset);
  gchar *  (*missing_uri)    (GESProject * self,
                              GError     * error,
                              GESAsset   * wrong_asset);
  gboolean (*loading_error)  (GESProject * self,
                              GError     * error,
                              gchar      * id,
                              GType extractable_type);
  gboolean (*loaded)         (GESProject  * self,
                              GESTimeline * timeline);

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_project_add_asset</NAME>
<RETURNS>gboolean   </RETURNS>
GESProject* project, GESAsset *asset
</FUNCTION>
<FUNCTION>
<NAME>ges_project_remove_asset</NAME>
<RETURNS>gboolean   </RETURNS>
GESProject *project, GESAsset * asset
</FUNCTION>
<FUNCTION>
<NAME>ges_project_list_assets</NAME>
<RETURNS>GList    * </RETURNS>
GESProject * project, GType filter
</FUNCTION>
<FUNCTION>
<NAME>ges_project_save</NAME>
<RETURNS>gboolean   </RETURNS>
GESProject * project, GESTimeline * timeline, const gchar *uri, GESAsset * formatter_asset, gboolean overwrite, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ges_project_load</NAME>
<RETURNS>gboolean   </RETURNS>
GESProject * project, GESTimeline * timeline, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ges_project_new</NAME>
<RETURNS>GESProject  * </RETURNS>
const gchar *uri
</FUNCTION>
<FUNCTION>
<NAME>ges_project_get_uri</NAME>
<RETURNS>gchar       * </RETURNS>
GESProject *project
</FUNCTION>
<FUNCTION>
<NAME>ges_project_get_asset</NAME>
<RETURNS>GESAsset    * </RETURNS>
GESProject * project, const gchar *id, GType extractable_type
</FUNCTION>
<FUNCTION>
<NAME>ges_project_create_asset</NAME>
<RETURNS>gboolean  </RETURNS>
GESProject * project, const gchar *id, GType extractable_type
</FUNCTION>
<FUNCTION>
<NAME>ges_project_create_asset_sync</NAME>
<RETURNS>GESAsset  * </RETURNS>
GESProject * project, const gchar * id, GType extractable_type, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ges_project_get_loading_assets</NAME>
<RETURNS>GList  * </RETURNS>
GESProject * project
</FUNCTION>
<FUNCTION>
<NAME>ges_project_add_encoding_profile</NAME>
<RETURNS>gboolean  </RETURNS>
GESProject *project, GstEncodingProfile *profile
</FUNCTION>
<FUNCTION>
<NAME>ges_project_list_encoding_profiles</NAME>
<RETURNS>const GList  *</RETURNS>
GESProject *project
</FUNCTION>
<FUNCTION>
<NAME>ges_add_missing_uri_relocation_uri</NAME>
<RETURNS>gboolean  </RETURNS>
const gchar * uri, gboolean recurse
</FUNCTION>
<STRUCT>
<NAME>GESProjectPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_SMART_ADDER</NAME>
#define GES_TYPE_SMART_ADDER             (ges_smart_adder_get_type ())
</MACRO>
<MACRO>
<NAME>GES_SMART_ADDER</NAME>
#define GES_SMART_ADDER(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_SMART_ADDER, GESSmartAdder))
</MACRO>
<MACRO>
<NAME>GES_SMART_ADDER_CLASS</NAME>
#define GES_SMART_ADDER_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_SMART_ADDER, GESSmartAdderClass))
</MACRO>
<MACRO>
<NAME>GES_IS_SMART_ADDER</NAME>
#define GES_IS_SMART_ADDER(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_SMART_ADDER))
</MACRO>
<MACRO>
<NAME>GES_IS_SMART_ADDER_CLASS</NAME>
#define GES_IS_SMART_ADDER_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_SMART_ADDER))
</MACRO>
<MACRO>
<NAME>GES_SMART_ADDER_GET_CLASS</NAME>
#define GES_SMART_ADDER_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_SMART_ADDER, GESSmartAdderClass))
</MACRO>
<STRUCT>
<NAME>GESSmartAdderClass</NAME>
struct _GESSmartAdderClass
{
  GstBinClass parent_class;

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESSmartAdder</NAME>
struct _GESSmartAdder
{
  GstBin parent_instance;

  GHashTable *pads_infos;
  GstPad *srcpad;
  GstElement *adder;
  GstElement *capsfilter;
  GMutex lock;

  GstCaps *caps;

  GESTrack *track;

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_smart_adder_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_smart_adder_new</NAME>
<RETURNS>GstElement *   </RETURNS>
GESTrack *track
</FUNCTION>
<MACRO>
<NAME>GES_TYPE_SOURCE_CLIP</NAME>
#define GES_TYPE_SOURCE_CLIP ges_source_clip_get_type()
</MACRO>
<MACRO>
<NAME>GES_SOURCE_CLIP</NAME>
#define GES_SOURCE_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_SOURCE_CLIP, GESSourceClip))
</MACRO>
<MACRO>
<NAME>GES_SOURCE_CLIP_CLASS</NAME>
#define GES_SOURCE_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_SOURCE_CLIP, GESSourceClipClass))
</MACRO>
<MACRO>
<NAME>GES_IS_SOURCE_CLIP</NAME>
#define GES_IS_SOURCE_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_SOURCE_CLIP))
</MACRO>
<MACRO>
<NAME>GES_IS_SOURCE_CLIP_CLASS</NAME>
#define GES_IS_SOURCE_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_SOURCE_CLIP))
</MACRO>
<MACRO>
<NAME>GES_SOURCE_CLIP_GET_CLASS</NAME>
#define GES_SOURCE_CLIP_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_SOURCE_CLIP, GESSourceClipClass))
</MACRO>
<STRUCT>
<NAME>GESSourceClip</NAME>
struct _GESSourceClip {
  GESClip parent;

  /*< private >*/
  GESSourceClipPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESSourceClipClass</NAME>
struct _GESSourceClipClass {
  /*< private >*/
  GESClipClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_source_clip_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESSourceClipPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_SOURCE</NAME>
#define GES_TYPE_SOURCE ges_source_get_type()
</MACRO>
<MACRO>
<NAME>GES_SOURCE</NAME>
#define GES_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_SOURCE, GESSource))
</MACRO>
<MACRO>
<NAME>GES_SOURCE_CLASS</NAME>
#define GES_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_SOURCE, GESSourceClass))
</MACRO>
<MACRO>
<NAME>GES_IS_SOURCE</NAME>
#define GES_IS_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_IS_SOURCE_CLASS</NAME>
#define GES_IS_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_SOURCE_GET_CLASS</NAME>
#define GES_SOURCE_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_SOURCE, GESSourceClass))
</MACRO>
<STRUCT>
<NAME>GESSource</NAME>
struct _GESSource {
  /*< private >*/
  GESTrackElement parent;

  GESSourcePrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESSourceClass</NAME>
struct _GESSourceClass {
  /*< private >*/
  GESTrackElementClass parent_class;

  /*< private >*/
  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_source_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESSourcePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_TEST_CLIP</NAME>
#define GES_TYPE_TEST_CLIP ges_test_clip_get_type()
</MACRO>
<MACRO>
<NAME>GES_TEST_CLIP</NAME>
#define GES_TEST_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_TEST_CLIP, GESTestClip))
</MACRO>
<MACRO>
<NAME>GES_TEST_CLIP_CLASS</NAME>
#define GES_TEST_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_TEST_CLIP, GESTestClipClass))
</MACRO>
<MACRO>
<NAME>GES_IS_TEST_CLIP</NAME>
#define GES_IS_TEST_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_TEST_CLIP))
</MACRO>
<MACRO>
<NAME>GES_IS_TEST_CLIP_CLASS</NAME>
#define GES_IS_TEST_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_TEST_CLIP))
</MACRO>
<MACRO>
<NAME>GES_TEST_CLIP_GET_CLASS</NAME>
#define GES_TEST_CLIP_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_TEST_CLIP, GESTestClipClass))
</MACRO>
<STRUCT>
<NAME>GESTestClip</NAME>
struct _GESTestClip {

  GESSourceClip parent;

  /*< private >*/
  GESTestClipPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESTestClipClass</NAME>
struct _GESTestClipClass {
  /*< private >*/
  GESSourceClipClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_test_clip_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_test_clip_is_muted</NAME>
<RETURNS>gboolean  </RETURNS>
GESTestClip * self
</FUNCTION>
<FUNCTION>
<NAME>ges_test_clip_get_frequency</NAME>
<RETURNS>gdouble  </RETURNS>
GESTestClip * self
</FUNCTION>
<FUNCTION>
<NAME>ges_test_clip_get_volume</NAME>
<RETURNS>gdouble  </RETURNS>
GESTestClip * self
</FUNCTION>
<FUNCTION>
<NAME>ges_test_clip_new</NAME>
<RETURNS>GESTestClip * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_test_clip_new_for_nick</NAME>
<RETURNS>GESTestClip * </RETURNS>
gchar * nick
</FUNCTION>
<STRUCT>
<NAME>GESTestClipPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_OVERLAY_TEXT_CLIP</NAME>
#define GES_TYPE_OVERLAY_TEXT_CLIP ges_text_overlay_clip_get_type()
</MACRO>
<MACRO>
<NAME>GES_OVERLAY_TEXT_CLIP</NAME>
#define GES_OVERLAY_TEXT_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_OVERLAY_TEXT_CLIP, GESTextOverlayClip))
</MACRO>
<MACRO>
<NAME>GES_OVERLAY_TEXT_CLIP_CLASS</NAME>
#define GES_OVERLAY_TEXT_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_OVERLAY_TEXT_CLIP, GESTextOverlayClipClass))
</MACRO>
<MACRO>
<NAME>GES_IS_OVERLAY_TEXT_CLIP</NAME>
#define GES_IS_OVERLAY_TEXT_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_OVERLAY_TEXT_CLIP))
</MACRO>
<MACRO>
<NAME>GES_IS_OVERLAY_TEXT_CLIP_CLASS</NAME>
#define GES_IS_OVERLAY_TEXT_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_OVERLAY_TEXT_CLIP))
</MACRO>
<MACRO>
<NAME>GES_OVERLAY_TEXT_CLIP_GET_CLASS</NAME>
#define GES_OVERLAY_TEXT_CLIP_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_OVERLAY_TEXT_CLIP, GESTextOverlayClipClass))
</MACRO>
<STRUCT>
<NAME>GESTextOverlayClip</NAME>
struct _GESTextOverlayClip
{
  GESOverlayClip parent;

  /*< private > */
  GESTextOverlayClipPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESTextOverlayClipClass</NAME>
struct _GESTextOverlayClipClass
{
  /*< private > */

  GESOverlayClipClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_text_overlay_clip_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_clip_get_text</NAME>
<RETURNS>const gchar  *</RETURNS>
GESTextOverlayClip * self
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_clip_get_font_desc</NAME>
<RETURNS>const gchar  *</RETURNS>
GESTextOverlayClip * self
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_clip_new</NAME>
<RETURNS>GESTextOverlayClip  *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESTextOverlayClipPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_TEXT_OVERLAY</NAME>
#define GES_TYPE_TEXT_OVERLAY ges_text_overlay_get_type()
</MACRO>
<MACRO>
<NAME>GES_TEXT_OVERLAY</NAME>
#define GES_TEXT_OVERLAY(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_TEXT_OVERLAY, GESTextOverlay))
</MACRO>
<MACRO>
<NAME>GES_TEXT_OVERLAY_CLASS</NAME>
#define GES_TEXT_OVERLAY_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_TEXT_OVERLAY, GESTextOverlayClass))
</MACRO>
<MACRO>
<NAME>GES_IS_TEXT_OVERLAY</NAME>
#define GES_IS_TEXT_OVERLAY(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_TEXT_OVERLAY))
</MACRO>
<MACRO>
<NAME>GES_IS_TEXT_OVERLAY_CLASS</NAME>
#define GES_IS_TEXT_OVERLAY_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_TEXT_OVERLAY))
</MACRO>
<MACRO>
<NAME>GES_TEXT_OVERLAY_GET_CLASS</NAME>
#define GES_TEXT_OVERLAY_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_TEXT_OVERLAY, GESTextOverlayClass))
</MACRO>
<STRUCT>
<NAME>GESTextOverlay</NAME>
struct _GESTextOverlay
{
  GESOperation parent;

  /*< private > */
  GESTextOverlayPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESTextOverlayClass</NAME>
struct _GESTextOverlayClass
{
  GESOperationClass parent_class;

  /*< private > */

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_text_overlay_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_set_text</NAME>
<RETURNS>void  </RETURNS>
GESTextOverlay * self, const gchar * text
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_set_font_desc</NAME>
<RETURNS>void  </RETURNS>
GESTextOverlay * self, const gchar * font_desc
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_set_halignment</NAME>
<RETURNS>void  </RETURNS>
GESTextOverlay * self, GESTextHAlign halign
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_set_valignment</NAME>
<RETURNS>void  </RETURNS>
GESTextOverlay * self, GESTextVAlign valign
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_set_color</NAME>
<RETURNS>void  </RETURNS>
GESTextOverlay * self, guint32 color
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_set_xpos</NAME>
<RETURNS>void  </RETURNS>
GESTextOverlay * self, gdouble position
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_set_ypos</NAME>
<RETURNS>void  </RETURNS>
GESTextOverlay * self, gdouble position
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_get_text</NAME>
<RETURNS>const gchar  *</RETURNS>
GESTextOverlay * self
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_get_font_desc</NAME>
<RETURNS>const char  *</RETURNS>
GESTextOverlay * self
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_get_halignment</NAME>
<RETURNS>GESTextHAlign  </RETURNS>
GESTextOverlay * self
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_get_valignment</NAME>
<RETURNS>GESTextVAlign  </RETURNS>
GESTextOverlay * self
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_get_color</NAME>
<RETURNS>const guint32  </RETURNS>
GESTextOverlay * self
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_get_xpos</NAME>
<RETURNS>const gdouble  </RETURNS>
GESTextOverlay * self
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_get_ypos</NAME>
<RETURNS>const gdouble  </RETURNS>
GESTextOverlay * self
</FUNCTION>
<FUNCTION>
<NAME>ges_text_overlay_new</NAME>
<RETURNS>GESTextOverlay  *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESTextOverlayPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_TIMELINE_ELEMENT</NAME>
#define GES_TYPE_TIMELINE_ELEMENT             (ges_timeline_element_get_type ())
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_ELEMENT</NAME>
#define GES_TIMELINE_ELEMENT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_TIMELINE_ELEMENT, GESTimelineElement))
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_ELEMENT_CLASS</NAME>
#define GES_TIMELINE_ELEMENT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_TIMELINE_ELEMENT, GESTimelineElementClass))
</MACRO>
<MACRO>
<NAME>GES_IS_TIMELINE_ELEMENT</NAME>
#define GES_IS_TIMELINE_ELEMENT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_TIMELINE_ELEMENT))
</MACRO>
<MACRO>
<NAME>GES_IS_TIMELINE_ELEMENT_CLASS</NAME>
#define GES_IS_TIMELINE_ELEMENT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_TIMELINE_ELEMENT))
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_ELEMENT_GET_CLASS</NAME>
#define GES_TIMELINE_ELEMENT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_TIMELINE_ELEMENT, GESTimelineElementClass))
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_ELEMENT_START</NAME>
#define GES_TIMELINE_ELEMENT_START(obj) (((GESTimelineElement*)obj)->start)
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_ELEMENT_END</NAME>
#define GES_TIMELINE_ELEMENT_END(obj) ((((GESTimelineElement*)obj)->start) + (((GESTimelineElement*)obj)->duration))
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_ELEMENT_INPOINT</NAME>
#define GES_TIMELINE_ELEMENT_INPOINT(obj) (((GESTimelineElement*)obj)->inpoint)
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_ELEMENT_DURATION</NAME>
#define GES_TIMELINE_ELEMENT_DURATION(obj) (((GESTimelineElement*)obj)->duration)
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_ELEMENT_MAX_DURATION</NAME>
#define GES_TIMELINE_ELEMENT_MAX_DURATION(obj) (((GESTimelineElement*)obj)->maxduration)
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_ELEMENT_PRIORITY</NAME>
#define GES_TIMELINE_ELEMENT_PRIORITY(obj) (((GESTimelineElement*)obj)->priority)
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_ELEMENT_NO_LAYER_PRIORITY</NAME>
#define GES_TIMELINE_ELEMENT_NO_LAYER_PRIORITY ((guint32) -1)
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_ELEMENT_LAYER_PRIORITY</NAME>
#define GES_TIMELINE_ELEMENT_LAYER_PRIORITY(obj) (ges_timeline_element_get_layer_priority(((GESTimelineElement*)obj)))
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_ELEMENT_PARENT</NAME>
#define GES_TIMELINE_ELEMENT_PARENT(obj) (((GESTimelineElement*)obj)->parent)
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_ELEMENT_TIMELINE</NAME>
#define GES_TIMELINE_ELEMENT_TIMELINE(obj) (((GESTimelineElement*)obj)->timeline)
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_ELEMENT_NAME</NAME>
#define GES_TIMELINE_ELEMENT_NAME(obj) (((GESTimelineElement*)obj)->name)
</MACRO>
<STRUCT>
<NAME>GESTimelineElement</NAME>
struct _GESTimelineElement
{
  GInitiallyUnowned parent_instance;

  /*< public > */
  /*< read only >*/
  GESTimelineElement *parent;
  GESAsset *asset;
  GstClockTime start;
  GstClockTime inpoint;
  GstClockTime duration;
  GstClockTime maxduration;
  guint32 priority;
  GESTimeline *timeline;
  gchar *name;

  /*< private >*/
  GESTimelineElementPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING_LARGE];
};
</STRUCT>
<STRUCT>
<NAME>GESTimelineElementClass</NAME>
struct _GESTimelineElementClass
{
  GInitiallyUnownedClass parent_class;

  /*< public > */
  gboolean (*set_parent)       (GESTimelineElement * self, GESTimelineElement *parent);
  gboolean (*set_start)        (GESTimelineElement * self, GstClockTime start);
  gboolean (*set_inpoint)      (GESTimelineElement * self, GstClockTime inpoint);
  gboolean (*set_duration)     (GESTimelineElement * self, GstClockTime duration);
  gboolean (*set_max_duration) (GESTimelineElement * self, GstClockTime maxduration);
  gboolean (*set_priority)     (GESTimelineElement * self, guint32 priority); /* set_priority is now protected */

  gboolean (*ripple)           (GESTimelineElement *self, guint64  start);
  gboolean (*ripple_end)       (GESTimelineElement *self, guint64  end);
  gboolean (*roll_start)       (GESTimelineElement *self, guint64  start);
  gboolean (*roll_end)         (GESTimelineElement *self, guint64  end);
  gboolean (*trim)             (GESTimelineElement *self, guint64  start);
  void     (*deep_copy)        (GESTimelineElement *self, GESTimelineElement *copy);

  GESTimelineElement * (*paste) (GESTimelineElement *self,
                                   GESTimelineElement *ref_element,
                                   GstClockTime paste_position);

  GParamSpec** (*list_children_properties) (GESTimelineElement * self, guint *n_properties);
  gboolean (*lookup_child)                 (GESTimelineElement *self, const gchar *prop_name,
                                            GObject **child, GParamSpec **pspec);
  GESTrackType (*get_track_types)          (GESTimelineElement * self);
  void         (*set_child_property)       (GESTimelineElement * self, GObject *child,
                                            GParamSpec *pspec, GValue *value);

  guint32      (*get_layer_priority)       (GESTimelineElement *self);

  /*< private > */
  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING_LARGE - 4];
};
</STRUCT>
<FUNCTION>
<NAME>ges_timeline_element_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_get_parent</NAME>
<RETURNS>GESTimelineElement  * </RETURNS>
GESTimelineElement * self
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_set_parent</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, GESTimelineElement *parent
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_set_timeline</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, GESTimeline *timeline
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_set_start</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, GstClockTime start
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_set_inpoint</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, GstClockTime inpoint
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_set_duration</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, GstClockTime duration
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_set_max_duration</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, GstClockTime maxduration
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_set_priority</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, guint32 priority
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_get_start</NAME>
<RETURNS>GstClockTime  </RETURNS>
GESTimelineElement *self
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_get_inpoint</NAME>
<RETURNS>GstClockTime  </RETURNS>
GESTimelineElement *self
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_get_duration</NAME>
<RETURNS>GstClockTime  </RETURNS>
GESTimelineElement *self
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_get_max_duration</NAME>
<RETURNS>GstClockTime  </RETURNS>
GESTimelineElement *self
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_get_timeline</NAME>
<RETURNS>GESTimeline  * </RETURNS>
GESTimelineElement *self
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_get_priority</NAME>
<RETURNS>guint32  </RETURNS>
GESTimelineElement *self
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_ripple</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, GstClockTime  start
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_ripple_end</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, GstClockTime  end
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_roll_start</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, GstClockTime  start
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_roll_end</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, GstClockTime  end
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_trim</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, GstClockTime  start
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_copy</NAME>
<RETURNS>GESTimelineElement  * </RETURNS>
GESTimelineElement *self, gboolean deep
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_get_name</NAME>
<RETURNS>gchar   * </RETURNS>
GESTimelineElement *self
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_set_name</NAME>
<RETURNS>gboolean   </RETURNS>
GESTimelineElement *self, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_lookup_child</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, const gchar *prop_name, GObject  **child, GParamSpec **pspec
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_set_child_properties</NAME>
<RETURNS>void  </RETURNS>
GESTimelineElement * self, const gchar * first_property_name, ...
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_set_child_property</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, const gchar *property_name, const GValue * value
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_get_child_property</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement *self, const gchar *property_name, GValue * value
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_add_child_property</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement * self, GParamSpec *pspec, GObject *child
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_remove_child_property</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimelineElement * self, GParamSpec *pspec
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_paste</NAME>
<RETURNS>GESTimelineElement  * </RETURNS>
GESTimelineElement * self, GstClockTime paste_position
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_get_track_types</NAME>
<RETURNS>GESTrackType  </RETURNS>
GESTimelineElement * self
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_element_get_layer_priority</NAME>
<RETURNS>guint32  </RETURNS>
GESTimelineElement * self
</FUNCTION>
<STRUCT>
<NAME>GESTimelineElementPrivate</NAME>
</STRUCT>
<FUNCTION>
<NAME>timeline_tree_track_element</NAME>
<RETURNS>void  </RETURNS>
GNode *root, GESTimelineElement *element
</FUNCTION>
<FUNCTION>
<NAME>timeline_tree_stop_tracking_element</NAME>
<RETURNS>void  </RETURNS>
GNode *root, GESTimelineElement *element
</FUNCTION>
<FUNCTION>
<NAME>timeline_tree_can_move_element</NAME>
<RETURNS>gboolean  </RETURNS>
GNode *root, GESTimelineElement *element, guint32 priority, GstClockTime start, GstClockTime duration, GList *moving_track_elements
</FUNCTION>
<FUNCTION>
<NAME>timeline_tree_ripple</NAME>
<RETURNS>gboolean  </RETURNS>
GNode *root, gint64 layer_priority_offset, GstClockTimeDiff offset, GESTimelineElement *rippled_element, GESEdge moving_edge, GstClockTime snapping_distance
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_emit_snapping</NAME>
<RETURNS>void  </RETURNS>
GESTimeline * timeline, GESTimelineElement * elem1, GESTimelineElement * elem2, GstClockTime snap_time
</FUNCTION>
<FUNCTION>
<NAME>timeline_tree_trim</NAME>
<RETURNS>gboolean  </RETURNS>
GNode *root, GESTimelineElement *element, gint64 layer_priority_offset, GstClockTimeDiff offset, GESEdge edge, GstClockTime snapping_distance
</FUNCTION>
<FUNCTION>
<NAME>timeline_tree_move</NAME>
<RETURNS>gboolean  </RETURNS>
GNode *root, GESTimelineElement *element, gint64 layer_priority_offset, GstClockTimeDiff offset, GESEdge edge, GstClockTime snapping_distance
</FUNCTION>
<FUNCTION>
<NAME>timeline_tree_roll</NAME>
<RETURNS>gboolean  </RETURNS>
GNode * root, GESTimelineElement * element, GstClockTimeDiff offset, GESEdge edge, GstClockTime snapping_distance
</FUNCTION>
<USER_FUNCTION>
<NAME>GESTreeGetAutoTransitionFunc</NAME>
<RETURNS>GESAutoTransition </RETURNS>
GESTimeline * timeline,
                                           GESTrackElement * previous,
                                           GESTrackElement * next,
                                           GstClockTime transition_duration
</USER_FUNCTION>
<FUNCTION>
<NAME>timeline_tree_create_transitions</NAME>
<RETURNS>void  </RETURNS>
GNode *root, GESTreeGetAutoTransitionFunc get_auto_transition
</FUNCTION>
<FUNCTION>
<NAME>timeline_tree_get_duration</NAME>
<RETURNS>GstClockTime  </RETURNS>
GNode *root
</FUNCTION>
<FUNCTION>
<NAME>timeline_tree_debug</NAME>
<RETURNS>void  </RETURNS>
GNode * root
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_create_transition</NAME>
<RETURNS>GESAutoTransition  *</RETURNS>
GESTimeline * timeline, GESTrackElement * previous, GESTrackElement * next, GESClip * transition, GESLayer * layer, guint64 start, guint64 duration
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_find_auto_transition</NAME>
<RETURNS>GESAutoTransition  *</RETURNS>
GESTimeline * timeline, GESTrackElement * prev, GESTrackElement * next, GstClockTime transition_duration
</FUNCTION>
<FUNCTION>
<NAME>timeline_update_duration</NAME>
<RETURNS>void</RETURNS>
GESTimeline * timeline
</FUNCTION>
<FUNCTION>
<NAME>timeline_tree_init_debug</NAME>
<RETURNS>void  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GES_TYPE_TIMELINE</NAME>
#define GES_TYPE_TIMELINE ges_timeline_get_type()
</MACRO>
<MACRO>
<NAME>GES_TIMELINE</NAME>
#define GES_TIMELINE(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_TIMELINE, GESTimeline))
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_CLASS</NAME>
#define GES_TIMELINE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_TIMELINE, GESTimelineClass))
</MACRO>
<MACRO>
<NAME>GES_IS_TIMELINE</NAME>
#define GES_IS_TIMELINE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_TIMELINE))
</MACRO>
<MACRO>
<NAME>GES_IS_TIMELINE_CLASS</NAME>
#define GES_IS_TIMELINE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_TIMELINE))
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_GET_CLASS</NAME>
#define GES_TIMELINE_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_TIMELINE, GESTimelineClass))
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_GET_TRACKS</NAME>
#define GES_TIMELINE_GET_TRACKS(obj) (GES_TIMELINE (obj)->tracks)
</MACRO>
<MACRO>
<NAME>GES_TIMELINE_GET_LAYERS</NAME>
#define GES_TIMELINE_GET_LAYERS(obj) (GES_TIMELINE (obj)->layers)
</MACRO>
<MACRO>
<NAME>ges_timeline_get_project</NAME>
#define ges_timeline_get_project(obj) (GES_PROJECT (ges_extractable_get_asset (GES_EXTRACTABLE(obj))))
</MACRO>
<STRUCT>
<NAME>GESTimeline</NAME>
struct _GESTimeline {
  GstBin parent;

  /*< public > */
  /* <readonly> */
  GList *layers;
  GList *tracks;

  /*< private >*/
  GESTimelinePrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESTimelineClass</NAME>
struct _GESTimelineClass {
  GstBinClass parent_class;

  /*< private >*/

  void (*track_added)	(GESTimeline *timeline, GESTrack * track);
  void (*track_removed)	(GESTimeline *timeline, GESTrack * track);
  void (*layer_added)	(GESTimeline *timeline, GESLayer *layer);
  void (*layer_removed)	(GESTimeline *timeline, GESLayer *layer);
  void (*group_added) (GESTimeline *timeline, GESGroup *group);
  void (*group_removed) (GESTimeline *timeline, GESGroup *group, GPtrArray *children);

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_timeline_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_new</NAME>
<RETURNS>GESTimeline * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_new_from_uri</NAME>
<RETURNS>GESTimeline * </RETURNS>
const gchar *uri, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_load_from_uri</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimeline *timeline, const gchar *uri, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_save_to_uri</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimeline * timeline, const gchar * uri, GESAsset *formatter_asset, gboolean overwrite, GError ** error
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_add_layer</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimeline *timeline, GESLayer *layer
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_append_layer</NAME>
<RETURNS>GESLayer  * </RETURNS>
GESTimeline * timeline
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_remove_layer</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimeline *timeline, GESLayer *layer
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_get_layers</NAME>
<RETURNS>GList * </RETURNS>
GESTimeline *timeline
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_get_layer</NAME>
<RETURNS>GESLayer * </RETURNS>
GESTimeline *timeline, guint priority
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_add_track</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimeline *timeline, GESTrack *track
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_remove_track</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimeline *timeline, GESTrack *track
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_get_track_for_pad</NAME>
<RETURNS>GESTrack  * </RETURNS>
GESTimeline *timeline, GstPad *pad
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_get_pad_for_track</NAME>
<RETURNS>GstPad  * </RETURNS>
GESTimeline * timeline, GESTrack *track
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_get_tracks</NAME>
<RETURNS>GList  *</RETURNS>
GESTimeline *timeline
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_get_groups</NAME>
<RETURNS>GList * </RETURNS>
GESTimeline * timeline
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_commit</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimeline * timeline
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_commit_sync</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimeline * timeline
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_get_duration</NAME>
<RETURNS>GstClockTime  </RETURNS>
GESTimeline *timeline
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_get_auto_transition</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimeline * timeline
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_set_auto_transition</NAME>
<RETURNS>void  </RETURNS>
GESTimeline * timeline, gboolean auto_transition
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_get_snapping_distance</NAME>
<RETURNS>GstClockTime  </RETURNS>
GESTimeline * timeline
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_set_snapping_distance</NAME>
<RETURNS>void  </RETURNS>
GESTimeline * timeline, GstClockTime snapping_distance
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_get_element</NAME>
<RETURNS>GESTimelineElement  * </RETURNS>
GESTimeline * timeline, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_is_empty</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimeline * timeline
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_paste_element</NAME>
<RETURNS>GESTimelineElement  * </RETURNS>
GESTimeline * timeline, GESTimelineElement * element, GstClockTime position, gint layer_priority
</FUNCTION>
<FUNCTION>
<NAME>ges_timeline_move_layer</NAME>
<RETURNS>gboolean  </RETURNS>
GESTimeline *timeline, GESLayer *layer, guint new_layer_priority
</FUNCTION>
<STRUCT>
<NAME>GESTimelinePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_TITLE_CLIP</NAME>
#define GES_TYPE_TITLE_CLIP ges_title_clip_get_type()
</MACRO>
<MACRO>
<NAME>GES_TITLE_CLIP</NAME>
#define GES_TITLE_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_TITLE_CLIP, GESTitleClip))
</MACRO>
<MACRO>
<NAME>GES_TITLE_CLIP_CLASS</NAME>
#define GES_TITLE_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_TITLE_CLIP, GESTitleClipClass))
</MACRO>
<MACRO>
<NAME>GES_IS_TITLE_CLIP</NAME>
#define GES_IS_TITLE_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_TITLE_CLIP))
</MACRO>
<MACRO>
<NAME>GES_IS_TITLE_CLIP_CLASS</NAME>
#define GES_IS_TITLE_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_TITLE_CLIP))
</MACRO>
<MACRO>
<NAME>GES_TITLE_CLIP_GET_CLASS</NAME>
#define GES_TITLE_CLIP_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_TITLE_CLIP, GESTitleClipClass))
</MACRO>
<STRUCT>
<NAME>GESTitleClip</NAME>
struct _GESTitleClip {
  GESSourceClip parent;

  /*< private >*/
  GESTitleClipPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESTitleClipClass</NAME>
struct _GESTitleClipClass {
  /*< private >*/
  GESSourceClipClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_title_clip_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_title_clip_get_text</NAME>
<RETURNS>const gchar * </RETURNS>
GESTitleClip * self
</FUNCTION>
<FUNCTION>
<NAME>ges_title_clip_new</NAME>
<RETURNS>GESTitleClip * </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESTitleClipPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_TITLE_SOURCE</NAME>
#define GES_TYPE_TITLE_SOURCE ges_title_source_get_type()
</MACRO>
<MACRO>
<NAME>GES_TITLE_SOURCE</NAME>
#define GES_TITLE_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_TITLE_SOURCE, GESTitleSource))
</MACRO>
<MACRO>
<NAME>GES_TITLE_SOURCE_CLASS</NAME>
#define GES_TITLE_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_TITLE_SOURCE, GESTitleSourceClass))
</MACRO>
<MACRO>
<NAME>GES_IS_TITLE_SOURCE</NAME>
#define GES_IS_TITLE_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_TITLE_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_IS_TITLE_SOURCE_CLASS</NAME>
#define GES_IS_TITLE_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_TITLE_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_TITLE_SOURCE_GET_CLASS</NAME>
#define GES_TITLE_SOURCE_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_TITLE_SOURCE, GESTitleSourceClass))
</MACRO>
<STRUCT>
<NAME>GESTitleSource</NAME>
struct _GESTitleSource {
  GESVideoSource parent;

  /*< private >*/
  GESTitleSourcePrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESTitleSourceClass</NAME>
struct _GESTitleSourceClass {
  GESVideoSourceClass parent_class;

  /*< private >*/

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING - 1];
};
</STRUCT>
<FUNCTION>
<NAME>ges_title_source_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_set_text</NAME>
<RETURNS>void  </RETURNS>
GESTitleSource *self, const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_set_font_desc</NAME>
<RETURNS>void  </RETURNS>
GESTitleSource *self, const gchar *font_desc
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_set_halignment</NAME>
<RETURNS>void  </RETURNS>
GESTitleSource *self, GESTextHAlign halign
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_set_valignment</NAME>
<RETURNS>void  </RETURNS>
GESTitleSource *self, GESTextVAlign valign
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_set_text_color</NAME>
<RETURNS>void  </RETURNS>
GESTitleSource *self, guint32 color
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_set_background_color</NAME>
<RETURNS>void  </RETURNS>
GESTitleSource *self, guint32 color
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_set_xpos</NAME>
<RETURNS>void  </RETURNS>
GESTitleSource *self, gdouble position
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_set_ypos</NAME>
<RETURNS>void  </RETURNS>
GESTitleSource *self, gdouble position
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_get_text</NAME>
<RETURNS>const gchar  *</RETURNS>
GESTitleSource *source
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_get_font_desc</NAME>
<RETURNS>const gchar  *</RETURNS>
GESTitleSource *source
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_get_halignment</NAME>
<RETURNS>GESTextHAlign  </RETURNS>
GESTitleSource *source
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_get_valignment</NAME>
<RETURNS>GESTextVAlign  </RETURNS>
GESTitleSource *source
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_get_text_color</NAME>
<RETURNS>const guint32  </RETURNS>
GESTitleSource *source
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_get_background_color</NAME>
<RETURNS>const guint32  </RETURNS>
GESTitleSource *source
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_get_xpos</NAME>
<RETURNS>const gdouble  </RETURNS>
GESTitleSource *source
</FUNCTION>
<FUNCTION>
<NAME>ges_title_source_get_ypos</NAME>
<RETURNS>const gdouble  </RETURNS>
GESTitleSource *source
</FUNCTION>
<STRUCT>
<NAME>GESTitleSourcePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_TRACK_ELEMENT_ASSET</NAME>
#define GES_TYPE_TRACK_ELEMENT_ASSET ges_track_element_asset_get_type()
</MACRO>
<MACRO>
<NAME>GES_TRACK_ELEMENT_ASSET</NAME>
#define GES_TRACK_ELEMENT_ASSET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_TRACK_ELEMENT_ASSET, GESTrackElementAsset))
</MACRO>
<MACRO>
<NAME>GES_TRACK_ELEMENT_ASSET_CLASS</NAME>
#define GES_TRACK_ELEMENT_ASSET_CLASS(klass)  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_TRACK_ELEMENT_ASSET, GESTrackElementAssetClass))
</MACRO>
<MACRO>
<NAME>GES_IS_TRACK_ELEMENT_ASSET</NAME>
#define GES_IS_TRACK_ELEMENT_ASSET(obj)  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_TRACK_ELEMENT_ASSET))
</MACRO>
<MACRO>
<NAME>GES_IS_TRACK_ELEMENT_ASSET_CLASS</NAME>
#define GES_IS_TRACK_ELEMENT_ASSET_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_TRACK_ELEMENT_ASSET))
</MACRO>
<MACRO>
<NAME>GES_TRACK_ELEMENT_ASSET_GET_CLASS</NAME>
#define GES_TRACK_ELEMENT_ASSET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_TRACK_ELEMENT_ASSET, GESTrackElementAssetClass))
</MACRO>
<FUNCTION>
<NAME>ges_track_element_asset_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESTrackElementAsset</NAME>
struct _GESTrackElementAsset
{
  GESAsset parent;

  /* <private> */
  GESTrackElementAssetPrivate *priv;

  /* Padding for API extension */
  gpointer __ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESTrackElementAssetClass</NAME>
struct _GESTrackElementAssetClass
{
  GESAssetClass parent_class;

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_track_element_asset_get_track_type</NAME>
<RETURNS>const GESTrackType  </RETURNS>
GESTrackElementAsset *asset
</FUNCTION>
<FUNCTION>
<NAME>ges_track_element_asset_set_track_type</NAME>
<RETURNS>void  </RETURNS>
GESTrackElementAsset * asset, GESTrackType type
</FUNCTION>
<STRUCT>
<NAME>GESTrackElementAssetPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_TRACK_ELEMENT</NAME>
#define GES_TYPE_TRACK_ELEMENT ges_track_element_get_type()
</MACRO>
<MACRO>
<NAME>GES_TRACK_ELEMENT</NAME>
#define GES_TRACK_ELEMENT(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_TRACK_ELEMENT, GESTrackElement))
</MACRO>
<MACRO>
<NAME>GES_TRACK_ELEMENT_CLASS</NAME>
#define GES_TRACK_ELEMENT_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_TRACK_ELEMENT, GESTrackElementClass))
</MACRO>
<MACRO>
<NAME>GES_IS_TRACK_ELEMENT</NAME>
#define GES_IS_TRACK_ELEMENT(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_TRACK_ELEMENT))
</MACRO>
<MACRO>
<NAME>GES_IS_TRACK_ELEMENT_CLASS</NAME>
#define GES_IS_TRACK_ELEMENT_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_TRACK_ELEMENT))
</MACRO>
<MACRO>
<NAME>GES_TRACK_ELEMENT_GET_CLASS</NAME>
#define GES_TRACK_ELEMENT_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_TRACK_ELEMENT, GESTrackElementClass))
</MACRO>
<STRUCT>
<NAME>GESTrackElement</NAME>
struct _GESTrackElement {
  GESTimelineElement parent;

  /*< private >*/
  gboolean active;

  GESTrackElementPrivate *priv;

  GESAsset *asset;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING_LARGE];
};
</STRUCT>
<STRUCT>
<NAME>GESTrackElementClass</NAME>
struct _GESTrackElementClass {
  /*< private >*/
  GESTimelineElementClass parent_class;

  /*< public >*/
  /* virtual methods for subclasses */
  const gchar  *nleobject_factorytype;
  GstElement*  (*create_gnl_object)        (GESTrackElement * object);
  GstElement*  (*create_element)           (GESTrackElement * object);

  void (*active_changed)       (GESTrackElement *object, gboolean active);

  /*< private >*/
  /* signals (currently unused) */
  void  (*changed)  (GESTrackElement * object);

  /*< public >*/
  /* virtual methods for subclasses */
  GParamSpec** (*list_children_properties) (GESTrackElement * object,
              guint *n_properties);
  gboolean (*lookup_child)                 (GESTrackElement *object,
                                            const gchar *prop_name,
                                            GstElement **element,
                                            GParamSpec **pspec);
  /*< private >*/
  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING_LARGE];
};
</STRUCT>
<FUNCTION>
<NAME>ges_track_element_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_track_element_get_track</NAME>
<RETURNS>GESTrack * </RETURNS>
GESTrackElement * object
</FUNCTION>
<FUNCTION>
<NAME>ges_track_element_get_track_type</NAME>
<RETURNS>GESTrackType  </RETURNS>
GESTrackElement * object
</FUNCTION>
<FUNCTION>
<NAME>ges_track_element_set_track_type</NAME>
<RETURNS>void  </RETURNS>
GESTrackElement * object, GESTrackType     type
</FUNCTION>
<FUNCTION>
<NAME>ges_track_element_get_nleobject</NAME>
<RETURNS>GstElement  * </RETURNS>
GESTrackElement * object
</FUNCTION>
<FUNCTION>
<NAME>ges_track_element_get_gnlobject</NAME>
<RETURNS>GstElement  * </RETURNS>
GESTrackElement * object
</FUNCTION>
<FUNCTION>
<NAME>ges_track_element_get_element</NAME>
<RETURNS>GstElement  * </RETURNS>
GESTrackElement * object
</FUNCTION>
<FUNCTION>
<NAME>ges_track_element_set_active</NAME>
<RETURNS>gboolean  </RETURNS>
GESTrackElement * object, gboolean active
</FUNCTION>
<FUNCTION>
<NAME>ges_track_element_is_active</NAME>
<RETURNS>gboolean  </RETURNS>
GESTrackElement * object
</FUNCTION>
<FUNCTION>
<NAME>ges_track_element_lookup_child</NAME>
<RETURNS>gboolean  </RETURNS>
GESTrackElement *object, const gchar *prop_name, GstElement **element, GParamSpec **pspec
</FUNCTION>
<FUNCTION>
<NAME>ges_track_element_get_child_properties</NAME>
<RETURNS>void  </RETURNS>
GESTrackElement *object, const gchar * first_property_name, ...
</FUNCTION>
<FUNCTION>
<NAME>ges_track_element_set_child_properties</NAME>
<RETURNS>void  </RETURNS>
GESTrackElement * object, const gchar * first_property_name, ...
</FUNCTION>
<FUNCTION>
<NAME>ges_track_element_set_child_property</NAME>
<RETURNS>gboolean  </RETURNS>
GESTrackElement *object, const gchar *property_name, GValue * value
</FUNCTION>
<FUNCTION>
<NAME>ges_track_element_get_child_property</NAME>
<RETURNS>gboolean  </RETURNS>
GESTrackElement *object, const gchar *property_name, GValue * value
</FUNCTION>
<STRUCT>
<NAME>GESTrackElementPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_TRACK</NAME>
#define GES_TYPE_TRACK            ges_track_get_type()
</MACRO>
<MACRO>
<NAME>GES_TRACK</NAME>
#define GES_TRACK(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_TRACK, GESTrack))
</MACRO>
<MACRO>
<NAME>GES_TRACK_CLASS</NAME>
#define GES_TRACK_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_TRACK, GESTrackClass))
</MACRO>
<MACRO>
<NAME>GES_IS_TRACK</NAME>
#define GES_IS_TRACK(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_TRACK))
</MACRO>
<MACRO>
<NAME>GES_IS_TRACK_CLASS</NAME>
#define GES_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_TRACK))
</MACRO>
<MACRO>
<NAME>GES_TRACK_GET_CLASS</NAME>
#define GES_TRACK_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_TRACK, GESTrackClass))
</MACRO>
<USER_FUNCTION>
<NAME>GESCreateElementForGapFunc</NAME>
<RETURNS>GstElement *</RETURNS>
GESTrack *track
</USER_FUNCTION>
<STRUCT>
<NAME>GESTrack</NAME>
struct _GESTrack
{
  GstBin parent;

  /*< public >*/
  /* READ-ONLY */
  GESTrackType     type;

  /*< private >*/
  GESTrackPrivate* priv;
  /* Padding for API extension */
  gpointer         _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESTrackClass</NAME>
struct _GESTrackClass
{
  /*< private >*/
  GstBinClass parent_class;

  GstElement * (*get_mixing_element) (GESTrack *track);

  /* Padding for API extension */
  gpointer    _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_track_get_caps</NAME>
<RETURNS>const GstCaps *     </RETURNS>
GESTrack *track
</FUNCTION>
<FUNCTION>
<NAME>ges_track_get_elements</NAME>
<RETURNS>GList *             </RETURNS>
GESTrack *track
</FUNCTION>
<FUNCTION>
<NAME>ges_track_get_timeline</NAME>
<RETURNS>const GESTimeline * </RETURNS>
GESTrack *track
</FUNCTION>
<FUNCTION>
<NAME>ges_track_commit</NAME>
<RETURNS>gboolean            </RETURNS>
GESTrack *track
</FUNCTION>
<FUNCTION>
<NAME>ges_track_set_timeline</NAME>
<RETURNS>void                </RETURNS>
GESTrack *track, GESTimeline *timeline
</FUNCTION>
<FUNCTION>
<NAME>ges_track_add_element</NAME>
<RETURNS>gboolean            </RETURNS>
GESTrack *track, GESTrackElement *object
</FUNCTION>
<FUNCTION>
<NAME>ges_track_remove_element</NAME>
<RETURNS>gboolean            </RETURNS>
GESTrack *track, GESTrackElement *object
</FUNCTION>
<FUNCTION>
<NAME>ges_track_set_create_element_for_gap_func</NAME>
<RETURNS>void                </RETURNS>
GESTrack *track, GESCreateElementForGapFunc func
</FUNCTION>
<FUNCTION>
<NAME>ges_track_set_mixing</NAME>
<RETURNS>void                </RETURNS>
GESTrack *track, gboolean mixing
</FUNCTION>
<FUNCTION>
<NAME>ges_track_get_mixing</NAME>
<RETURNS>gboolean            </RETURNS>
GESTrack *track
</FUNCTION>
<FUNCTION>
<NAME>ges_track_set_restriction_caps</NAME>
<RETURNS>void                </RETURNS>
GESTrack *track, const GstCaps *caps
</FUNCTION>
<FUNCTION>
<NAME>ges_track_update_restriction_caps</NAME>
<RETURNS>void                </RETURNS>
GESTrack *track, const GstCaps *caps
</FUNCTION>
<FUNCTION>
<NAME>ges_track_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_track_new</NAME>
<RETURNS>GESTrack *          </RETURNS>
GESTrackType type, GstCaps * caps
</FUNCTION>
<STRUCT>
<NAME>GESTrackPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_TRANSITION_CLIP</NAME>
#define GES_TYPE_TRANSITION_CLIP ges_transition_clip_get_type()
</MACRO>
<MACRO>
<NAME>GES_TRANSITION_CLIP</NAME>
#define GES_TRANSITION_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_TRANSITION_CLIP, GESTransitionClip))
</MACRO>
<MACRO>
<NAME>GES_TRANSITION_CLIP_CLASS</NAME>
#define GES_TRANSITION_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_TRANSITION_CLIP, GESTransitionClipClass))
</MACRO>
<MACRO>
<NAME>GES_IS_TRANSITION_CLIP</NAME>
#define GES_IS_TRANSITION_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_TRANSITION_CLIP))
</MACRO>
<MACRO>
<NAME>GES_IS_TRANSITION_CLIP_CLASS</NAME>
#define GES_IS_TRANSITION_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_TRANSITION_CLIP))
</MACRO>
<MACRO>
<NAME>GES_TRANSITION_CLIP_GET_CLASS</NAME>
#define GES_TRANSITION_CLIP_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_TRANSITION_CLIP, GESTransitionClipClass))
</MACRO>
<STRUCT>
<NAME>GESTransitionClip</NAME>
struct _GESTransitionClip {
  /*< private >*/
  GESBaseTransitionClip parent;

  /*< public >*/
  GESVideoStandardTransitionType vtype;

  /*< private >*/
  GESTransitionClipPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESTransitionClipClass</NAME>
struct _GESTransitionClipClass {
  /*< private >*/
  GESBaseTransitionClipClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_transition_clip_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_transition_clip_new</NAME>
<RETURNS>GESTransitionClip  *</RETURNS>
GESVideoStandardTransitionType vtype
</FUNCTION>
<FUNCTION>
<NAME>ges_transition_clip_new_for_nick</NAME>
<RETURNS>GESTransitionClip  *</RETURNS>
char *nick
</FUNCTION>
<STRUCT>
<NAME>GESTransitionClipPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_TRANSITION</NAME>
#define GES_TYPE_TRANSITION ges_transition_get_type()
</MACRO>
<MACRO>
<NAME>GES_TRANSITION</NAME>
#define GES_TRANSITION(obj) \
    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_TRANSITION,\
        GESTransition))
</MACRO>
<MACRO>
<NAME>GES_TRANSITION_CLASS</NAME>
#define GES_TRANSITION_CLASS(klass) \
    (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_TRANSITION,\
        GESTransitionClass))
</MACRO>
<MACRO>
<NAME>GES_IS_TRANSITION</NAME>
#define GES_IS_TRANSITION(obj) \
    (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_TRANSITION))
</MACRO>
<MACRO>
<NAME>GES_IS_TRANSITION_CLASS</NAME>
#define GES_IS_TRANSITION_CLASS(klass) \
    (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_TRANSITION))
</MACRO>
<MACRO>
<NAME>GES_TRANSITION_GET_CLASS</NAME>
#define GES_TRANSITION_GET_CLASS(obj) \
    (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_TRANSITION,\
        GESTransitionClass))
</MACRO>
<STRUCT>
<NAME>GESTransition</NAME>
struct _GESTransition
{
  /*< private >*/
  GESOperation parent;

  GESTransitionPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESTransitionClass</NAME>
struct _GESTransitionClass {
  /*< private >*/
  GESOperationClass parent_class;
  
  /*< private >*/
  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_transition_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESTransitionPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_URI_CLIP_ASSET</NAME>
#define GES_TYPE_URI_CLIP_ASSET ges_uri_clip_asset_get_type()
</MACRO>
<MACRO>
<NAME>GES_URI_CLIP_ASSET</NAME>
#define GES_URI_CLIP_ASSET(obj) \
    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_URI_CLIP_ASSET, GESUriClipAsset))
</MACRO>
<MACRO>
<NAME>GES_URI_CLIP_ASSET_CLASS</NAME>
#define GES_URI_CLIP_ASSET_CLASS(klass) \
    (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_URI_CLIP_ASSET, GESUriClipAssetClass))
</MACRO>
<MACRO>
<NAME>GES_IS_URI_CLIP_ASSET</NAME>
#define GES_IS_URI_CLIP_ASSET(obj) \
    (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_URI_CLIP_ASSET))
</MACRO>
<MACRO>
<NAME>GES_IS_URI_CLIP_ASSET_CLASS</NAME>
#define GES_IS_URI_CLIP_ASSET_CLASS(klass) \
    (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_URI_CLIP_ASSET))
</MACRO>
<MACRO>
<NAME>GES_URI_CLIP_ASSET_GET_CLASS</NAME>
#define GES_URI_CLIP_ASSET_GET_CLASS(obj) \
    (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_URI_CLIP_ASSET, GESUriClipAssetClass))
</MACRO>
<FUNCTION>
<NAME>ges_uri_clip_asset_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESUriClipAsset</NAME>
struct _GESUriClipAsset
{
  GESClipAsset parent;

  /* <private> */
  GESUriClipAssetPrivate *priv;

  /* Padding for API extension */
  gpointer __ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESUriClipAssetClass</NAME>
struct _GESUriClipAssetClass
{
  GESClipAssetClass parent_class;

  /* <private> */
  GstDiscoverer *discoverer;
  GstDiscoverer *sync_discoverer;

  void (*discovered) (GstDiscoverer * discoverer, GstDiscovererInfo * info,
                     GError * err, gpointer user_data);

  gpointer _ges_reserved[GES_PADDING -1];
};
</STRUCT>
<FUNCTION>
<NAME>ges_uri_clip_asset_get_info</NAME>
<RETURNS>GstDiscovererInfo  *</RETURNS>
const GESUriClipAsset * self
</FUNCTION>
<FUNCTION>
<NAME>ges_uri_clip_asset_get_duration</NAME>
<RETURNS>GstClockTime  </RETURNS>
GESUriClipAsset *self
</FUNCTION>
<FUNCTION>
<NAME>ges_uri_clip_asset_is_image</NAME>
<RETURNS>gboolean  </RETURNS>
GESUriClipAsset *self
</FUNCTION>
<FUNCTION>
<NAME>ges_uri_clip_asset_new</NAME>
<RETURNS>void  </RETURNS>
const gchar *uri, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>ges_uri_clip_asset_finish</NAME>
<RETURNS>GESUriClipAsset  * </RETURNS>
GAsyncResult * res, GError ** error
</FUNCTION>
<FUNCTION>
<NAME>ges_uri_clip_asset_request_sync</NAME>
<RETURNS>GESUriClipAsset * </RETURNS>
const gchar *uri, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ges_uri_clip_asset_class_set_timeout</NAME>
<RETURNS>void  </RETURNS>
GESUriClipAssetClass *klass, GstClockTime timeout
</FUNCTION>
<FUNCTION>
<NAME>ges_uri_clip_asset_get_stream_assets</NAME>
<RETURNS>const GList  * </RETURNS>
GESUriClipAsset *self
</FUNCTION>
<MACRO>
<NAME>GES_TYPE_URI_SOURCE_ASSET</NAME>
#define GES_TYPE_URI_SOURCE_ASSET ges_uri_source_asset_get_type()
</MACRO>
<MACRO>
<NAME>GES_URI_SOURCE_ASSET</NAME>
#define GES_URI_SOURCE_ASSET(obj) \
    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_URI_SOURCE_ASSET, GESUriSourceAsset))
</MACRO>
<MACRO>
<NAME>GES_URI_SOURCE_ASSET_CLASS</NAME>
#define GES_URI_SOURCE_ASSET_CLASS(klass) \
    (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_URI_SOURCE_ASSET, GESUriSourceAssetClass))
</MACRO>
<MACRO>
<NAME>GES_IS_URI_SOURCE_ASSET</NAME>
#define GES_IS_URI_SOURCE_ASSET(obj) \
    (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_URI_SOURCE_ASSET))
</MACRO>
<MACRO>
<NAME>GES_IS_URI_SOURCE_ASSET_CLASS</NAME>
#define GES_IS_URI_SOURCE_ASSET_CLASS(klass) \
    (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_URI_SOURCE_ASSET))
</MACRO>
<MACRO>
<NAME>GES_URI_SOURCE_ASSET_GET_CLASS</NAME>
#define GES_URI_SOURCE_ASSET_GET_CLASS(obj) \
    (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_URI_SOURCE_ASSET, GESUriSourceAssetClass))
</MACRO>
<FUNCTION>
<NAME>ges_uri_source_asset_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESUriSourceAsset</NAME>
struct _GESUriSourceAsset
{
  GESTrackElementAsset parent;

  /* <private> */
  GESUriSourceAssetPrivate *priv;

  /* Padding for API extension */
  gpointer __ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESUriSourceAssetClass</NAME>
struct _GESUriSourceAssetClass
{
  GESTrackElementAssetClass parent_class;

  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_uri_source_asset_get_stream_info</NAME>
<RETURNS>GstDiscovererStreamInfo  * </RETURNS>
GESUriSourceAsset *asset
</FUNCTION>
<FUNCTION>
<NAME>ges_uri_source_asset_get_stream_uri</NAME>
<RETURNS>const gchar  * </RETURNS>
GESUriSourceAsset *asset
</FUNCTION>
<FUNCTION>
<NAME>ges_uri_source_asset_get_filesource_asset</NAME>
<RETURNS>const GESUriClipAsset  *</RETURNS>
GESUriSourceAsset *asset
</FUNCTION>
<STRUCT>
<NAME>GESUriClipAssetPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GESUriSourceAssetPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_URI_CLIP</NAME>
#define GES_TYPE_URI_CLIP ges_uri_clip_get_type()
</MACRO>
<MACRO>
<NAME>GES_URI_CLIP</NAME>
#define GES_URI_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_URI_CLIP, GESUriClip))
</MACRO>
<MACRO>
<NAME>GES_URI_CLIP_CLASS</NAME>
#define GES_URI_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_URI_CLIP, GESUriClipClass))
</MACRO>
<MACRO>
<NAME>GES_IS_URI_CLIP</NAME>
#define GES_IS_URI_CLIP(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_URI_CLIP))
</MACRO>
<MACRO>
<NAME>GES_IS_URI_CLIP_CLASS</NAME>
#define GES_IS_URI_CLIP_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_URI_CLIP))
</MACRO>
<MACRO>
<NAME>GES_URI_CLIP_GET_CLASS</NAME>
#define GES_URI_CLIP_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_URI_CLIP, GESUriClipClass))
</MACRO>
<STRUCT>
<NAME>GESUriClip</NAME>
struct _GESUriClip {
  GESSourceClip parent;

  /*< private >*/
  GESUriClipPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESUriClipClass</NAME>
struct _GESUriClipClass {
  /*< private >*/
  GESSourceClipClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_uri_clip_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_uri_clip_is_muted</NAME>
<RETURNS>gboolean  </RETURNS>
GESUriClip * self
</FUNCTION>
<FUNCTION>
<NAME>ges_uri_clip_is_image</NAME>
<RETURNS>gboolean  </RETURNS>
GESUriClip * self
</FUNCTION>
<FUNCTION>
<NAME>ges_uri_clip_get_uri</NAME>
<RETURNS>const gchar  *</RETURNS>
GESUriClip * self
</FUNCTION>
<FUNCTION>
<NAME>ges_uri_clip_new</NAME>
<RETURNS>GESUriClip * </RETURNS>
const gchar *uri
</FUNCTION>
<STRUCT>
<NAME>GESUriClipPrivate</NAME>
</STRUCT>
<FUNCTION>
<NAME>ges_timeline_new_audio_video</NAME>
<RETURNS>GESTimeline  * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_pspec_equal</NAME>
<RETURNS>gboolean  </RETURNS>
gconstpointer key_spec_1, gconstpointer key_spec_2
</FUNCTION>
<FUNCTION>
<NAME>ges_pspec_hash</NAME>
<RETURNS>guint  </RETURNS>
gconstpointer key_spec
</FUNCTION>
<MACRO>
<NAME>GES_VERSION_MAJOR</NAME>
#define GES_VERSION_MAJOR (1)
</MACRO>
<MACRO>
<NAME>GES_VERSION_MINOR</NAME>
#define GES_VERSION_MINOR (16)
</MACRO>
<MACRO>
<NAME>GES_VERSION_MICRO</NAME>
#define GES_VERSION_MICRO (0)
</MACRO>
<MACRO>
<NAME>GES_VERSION_NANO</NAME>
#define GES_VERSION_NANO  (0)
</MACRO>
<MACRO>
<NAME>GES_TYPE_VIDEO_SOURCE</NAME>
#define GES_TYPE_VIDEO_SOURCE ges_video_source_get_type()
</MACRO>
<MACRO>
<NAME>GES_VIDEO_SOURCE</NAME>
#define GES_VIDEO_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_VIDEO_SOURCE, GESVideoSource))
</MACRO>
<MACRO>
<NAME>GES_VIDEO_SOURCE_CLASS</NAME>
#define GES_VIDEO_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_VIDEO_SOURCE, GESVideoSourceClass))
</MACRO>
<MACRO>
<NAME>GES_IS_VIDEO_SOURCE</NAME>
#define GES_IS_VIDEO_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_VIDEO_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_IS_VIDEO_SOURCE_CLASS</NAME>
#define GES_IS_VIDEO_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_VIDEO_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_VIDEO_SOURCE_GET_CLASS</NAME>
#define GES_VIDEO_SOURCE_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_VIDEO_SOURCE, GESVideoSourceClass))
</MACRO>
<STRUCT>
<NAME>GESVideoSource</NAME>
struct _GESVideoSource {
  /*< private >*/
  GESSource parent;

  GESVideoSourcePrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESVideoSourceClass</NAME>
struct _GESVideoSourceClass {
  /*< private >*/
  GESSourceClass parent_class;

  /*< public >*/
  GstElement*  (*create_source)           (GESTrackElement * object);

  /*< private >*/
  /* Padding for API extension */
  union {
    gpointer _ges_reserved[GES_PADDING];
    struct {
      gboolean disable_scale_in_compositor;
    } abi;
  } ABI;
};
</STRUCT>
<FUNCTION>
<NAME>ges_video_source_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESVideoSourcePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_VIDEO_TEST_SOURCE</NAME>
#define GES_TYPE_VIDEO_TEST_SOURCE ges_video_test_source_get_type()
</MACRO>
<MACRO>
<NAME>GES_VIDEO_TEST_SOURCE</NAME>
#define GES_VIDEO_TEST_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_VIDEO_TEST_SOURCE, GESVideoTestSource))
</MACRO>
<MACRO>
<NAME>GES_VIDEO_TEST_SOURCE_CLASS</NAME>
#define GES_VIDEO_TEST_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_VIDEO_TEST_SOURCE, GESVideoTestSourceClass))
</MACRO>
<MACRO>
<NAME>GES_IS_VIDEO_TEST_SOURCE</NAME>
#define GES_IS_VIDEO_TEST_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_VIDEO_TEST_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_IS_VIDEO_TEST_SOURCE_CLASS</NAME>
#define GES_IS_VIDEO_TEST_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_VIDEO_TEST_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_VIDEO_TEST_SOURCE_GET_CLASS</NAME>
#define GES_VIDEO_TEST_SOURCE_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_VIDEO_TEST_SOURCE, GESVideoTestSourceClass))
</MACRO>
<STRUCT>
<NAME>GESVideoTestSource</NAME>
struct _GESVideoTestSource {
  /*< private >*/
  GESVideoSource parent;

  GESVideoTestSourcePrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESVideoTestSourceClass</NAME>
struct _GESVideoTestSourceClass {
  GESVideoSourceClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_video_test_source_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESVideoTestSourcePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_VIDEO_TRACK</NAME>
#define GES_TYPE_VIDEO_TRACK             (ges_video_track_get_type ())
</MACRO>
<MACRO>
<NAME>GES_VIDEO_TRACK</NAME>
#define GES_VIDEO_TRACK(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_VIDEO_TRACK, GESVideoTrack))
</MACRO>
<MACRO>
<NAME>GES_VIDEO_TRACK_CLASS</NAME>
#define GES_VIDEO_TRACK_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_VIDEO_TRACK, GESVideoTrackClass))
</MACRO>
<MACRO>
<NAME>GES_IS_VIDEO_TRACK</NAME>
#define GES_IS_VIDEO_TRACK(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_VIDEO_TRACK))
</MACRO>
<MACRO>
<NAME>GES_IS_VIDEO_TRACK_CLASS</NAME>
#define GES_IS_VIDEO_TRACK_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_VIDEO_TRACK))
</MACRO>
<MACRO>
<NAME>GES_VIDEO_TRACK_GET_CLASS</NAME>
#define GES_VIDEO_TRACK_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_VIDEO_TRACK, GESVideoTrackClass))
</MACRO>
<STRUCT>
<NAME>GESVideoTrackClass</NAME>
struct _GESVideoTrackClass
{
  GESTrackClass parent_class;

  /* Padding for API extension */
  gpointer    _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESVideoTrack</NAME>
struct _GESVideoTrack
{
  GESTrack parent_instance;

  /*< private >*/
  GESVideoTrackPrivate *priv;

  /* Padding for API extension */
  gpointer    _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_video_track_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_video_track_new</NAME>
<RETURNS>GESVideoTrack  * </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESVideoTrackPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_VIDEO_TRANSITION</NAME>
#define GES_TYPE_VIDEO_TRANSITION ges_video_transition_get_type()
</MACRO>
<MACRO>
<NAME>GES_VIDEO_TRANSITION</NAME>
#define GES_VIDEO_TRANSITION(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_VIDEO_TRANSITION, GESVideoTransition))
</MACRO>
<MACRO>
<NAME>GES_VIDEO_TRANSITION_CLASS</NAME>
#define GES_VIDEO_TRANSITION_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_VIDEO_TRANSITION, GESVideoTransitionClass))
</MACRO>
<MACRO>
<NAME>GES_IS_VIDEO_TRANSITION</NAME>
#define GES_IS_VIDEO_TRANSITION(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_VIDEO_TRANSITION))
</MACRO>
<MACRO>
<NAME>GES_IS_VIDEO_TRANSITION_CLASS</NAME>
#define GES_IS_VIDEO_TRANSITION_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_VIDEO_TRANSITION))
</MACRO>
<MACRO>
<NAME>GES_VIDEO_TRANSITION_GET_CLASS</NAME>
#define GES_VIDEO_TRANSITION_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_VIDEO_TRANSITION, GESVideoTransitionClass))
</MACRO>
<STRUCT>
<NAME>GESVideoTransition</NAME>
struct _GESVideoTransition {
  GESTransition parent;

  /*< private >*/

  GESVideoTransitionPrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESVideoTransitionClass</NAME>
struct _GESVideoTransitionClass {
  GESTransitionClass parent_class;

  /*< private >*/
  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_video_transition_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_video_transition_new</NAME>
<RETURNS>GESVideoTransition * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_video_transition_set_transition_type</NAME>
<RETURNS>gboolean  </RETURNS>
GESVideoTransition * self, GESVideoStandardTransitionType type
</FUNCTION>
<FUNCTION>
<NAME>ges_video_transition_set_border</NAME>
<RETURNS>void  </RETURNS>
GESVideoTransition * self, guint value
</FUNCTION>
<FUNCTION>
<NAME>ges_video_transition_get_border</NAME>
<RETURNS>gint  </RETURNS>
GESVideoTransition * self
</FUNCTION>
<FUNCTION>
<NAME>ges_video_transition_set_inverted</NAME>
<RETURNS>void  </RETURNS>
GESVideoTransition * self, gboolean inverted
</FUNCTION>
<FUNCTION>
<NAME>ges_video_transition_is_inverted</NAME>
<RETURNS>gboolean  </RETURNS>
GESVideoTransition * self
</FUNCTION>
<STRUCT>
<NAME>GESVideoTransitionPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_VIDEO_URI_SOURCE</NAME>
#define GES_TYPE_VIDEO_URI_SOURCE ges_video_uri_source_get_type()
</MACRO>
<MACRO>
<NAME>GES_VIDEO_URI_SOURCE</NAME>
#define GES_VIDEO_URI_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_VIDEO_URI_SOURCE, GESVideoUriSource))
</MACRO>
<MACRO>
<NAME>GES_VIDEO_URI_SOURCE_CLASS</NAME>
#define GES_VIDEO_URI_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_VIDEO_URI_SOURCE, GESVideoUriSourceClass))
</MACRO>
<MACRO>
<NAME>GES_IS_VIDEO_URI_SOURCE</NAME>
#define GES_IS_VIDEO_URI_SOURCE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_VIDEO_URI_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_IS_VIDEO_URI_SOURCE_CLASS</NAME>
#define GES_IS_VIDEO_URI_SOURCE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_VIDEO_URI_SOURCE))
</MACRO>
<MACRO>
<NAME>GES_VIDEO_URI_SOURCE_GET_CLASS</NAME>
#define GES_VIDEO_URI_SOURCE_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_VIDEO_URI_SOURCE, GESVideoUriSourceClass))
</MACRO>
<STRUCT>
<NAME>GESVideoUriSource</NAME>
struct _GESVideoUriSource {
  /*< private >*/
  GESVideoSource parent;

  gchar *uri;

  GESVideoUriSourcePrivate *priv;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<STRUCT>
<NAME>GESVideoUriSourceClass</NAME>
struct _GESVideoUriSourceClass {
  /*< private >*/
  GESVideoSourceClass parent_class;

  /* Padding for API extension */
  gpointer _ges_reserved[GES_PADDING];
};
</STRUCT>
<FUNCTION>
<NAME>ges_video_uri_source_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESVideoUriSourcePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GES_TYPE_XML_FORMATTER</NAME>
#define GES_TYPE_XML_FORMATTER (ges_xml_formatter_get_type ())
</MACRO>
<MACRO>
<NAME>GES_XML_FORMATTER</NAME>
#define GES_XML_FORMATTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_XML_FORMATTER, GESXmlFormatter))
</MACRO>
<MACRO>
<NAME>GES_XML_FORMATTER_CLASS</NAME>
#define GES_XML_FORMATTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_XML_FORMATTER, GESXmlFormatterClass))
</MACRO>
<MACRO>
<NAME>GES_IS_XML_FORMATTER</NAME>
#define GES_IS_XML_FORMATTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_XML_FORMATTER))
</MACRO>
<MACRO>
<NAME>GES_IS_XML_FORMATTER_CLASS</NAME>
#define GES_IS_XML_FORMATTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_XML_FORMATTER))
</MACRO>
<MACRO>
<NAME>GES_XML_FORMATTER_GET_CLASS</NAME>
#define GES_XML_FORMATTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_XML_FORMATTER, GESXmlFormatterClass))
</MACRO>
<FUNCTION>
<NAME>ges_xml_formatter_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GESXmlFormatterPrivate</NAME>
</STRUCT>
<FUNCTION>
<NAME>ges_init</NAME>
<RETURNS>gboolean  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_init_check</NAME>
<RETURNS>gboolean  </RETURNS>
int *argc, char **argv[], GError ** err
</FUNCTION>
<FUNCTION>
<NAME>ges_deinit</NAME>
<RETURNS>void      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_version</NAME>
<RETURNS>void      </RETURNS>
guint * major, guint * minor, guint * micro, guint * nano
</FUNCTION>
<FUNCTION>
<NAME>ges_validate_register_action_types</NAME>
<RETURNS>gboolean  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ges_is_initialized</NAME>
<RETURNS>gboolean  </RETURNS>
void
</FUNCTION>
