X-Git-Url: https://vcs.maemo.org/git/?a=blobdiff_plain;f=src%2Fmarina%2Fmarina%2FClassFactory.c;fp=src%2Fmarina%2Fmarina%2FClassFactory.c;h=6761d4190a5aa18f71362452aef68b194babdb54;hb=a712cd772f4f3db8bed7037bb95c4de94767b230;hp=0000000000000000000000000000000000000000;hpb=2f0296582bf5d3f51db40d299f434fc8240ca6a5;p=fillmore diff --git a/src/marina/marina/ClassFactory.c b/src/marina/marina/ClassFactory.c new file mode 100644 index 0000000..6761d41 --- /dev/null +++ b/src/marina/marina/ClassFactory.c @@ -0,0 +1,484 @@ +/* ClassFactory.c generated by valac, the Vala compiler + * generated from ClassFactory.vala, do not modify */ + +/* Copyright 2009-2010 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#include +#include +#include +#include +#include +#include + + +#define TYPE_TRACK_VIEW (track_view_get_type ()) +#define TRACK_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_VIEW, TrackView)) +#define IS_TRACK_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_VIEW)) +#define TRACK_VIEW_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_TRACK_VIEW, TrackViewIface)) + +typedef struct _TrackView TrackView; +typedef struct _TrackViewIface TrackViewIface; + +#define TYPE_CLIP_VIEW (clip_view_get_type ()) +#define CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLIP_VIEW, ClipView)) +#define CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLIP_VIEW, ClipViewClass)) +#define IS_CLIP_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLIP_VIEW)) +#define IS_CLIP_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLIP_VIEW)) +#define CLIP_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLIP_VIEW, ClipViewClass)) + +typedef struct _ClipView ClipView; +typedef struct _ClipViewClass ClipViewClass; + +#define MODEL_TYPE_TRACK (model_track_get_type ()) +#define MODEL_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRACK, ModelTrack)) +#define MODEL_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRACK, ModelTrackClass)) +#define MODEL_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRACK)) +#define MODEL_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRACK)) +#define MODEL_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRACK, ModelTrackClass)) + +typedef struct _ModelTrack ModelTrack; +typedef struct _ModelTrackClass ModelTrackClass; + +#define TYPE_CLASS_FACTORY (class_factory_get_type ()) +#define CLASS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CLASS_FACTORY, ClassFactory)) +#define CLASS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CLASS_FACTORY, ClassFactoryClass)) +#define IS_CLASS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CLASS_FACTORY)) +#define IS_CLASS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CLASS_FACTORY)) +#define CLASS_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CLASS_FACTORY, ClassFactoryClass)) + +typedef struct _ClassFactory ClassFactory; +typedef struct _ClassFactoryClass ClassFactoryClass; +typedef struct _ClassFactoryPrivate ClassFactoryPrivate; + +#define TYPE_TIME_LINE (time_line_get_type ()) +#define TIME_LINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TIME_LINE, TimeLine)) +#define TIME_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TIME_LINE, TimeLineClass)) +#define IS_TIME_LINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TIME_LINE)) +#define IS_TIME_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TIME_LINE)) +#define TIME_LINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TIME_LINE, TimeLineClass)) + +typedef struct _TimeLine TimeLine; +typedef struct _TimeLineClass TimeLineClass; + +#define TYPE_TRANSPORT_DELEGATE (transport_delegate_get_type ()) +#define TRANSPORT_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRANSPORT_DELEGATE, TransportDelegate)) +#define IS_TRANSPORT_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRANSPORT_DELEGATE)) +#define TRANSPORT_DELEGATE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_TRANSPORT_DELEGATE, TransportDelegateIface)) + +typedef struct _TransportDelegate TransportDelegate; +typedef struct _TransportDelegateIface TransportDelegateIface; + +#define TYPE_TRACK_VIEW_CONCRETE (track_view_concrete_get_type ()) +#define TRACK_VIEW_CONCRETE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK_VIEW_CONCRETE, TrackViewConcrete)) +#define TRACK_VIEW_CONCRETE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRACK_VIEW_CONCRETE, TrackViewConcreteClass)) +#define IS_TRACK_VIEW_CONCRETE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRACK_VIEW_CONCRETE)) +#define IS_TRACK_VIEW_CONCRETE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TRACK_VIEW_CONCRETE)) +#define TRACK_VIEW_CONCRETE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TRACK_VIEW_CONCRETE, TrackViewConcreteClass)) + +typedef struct _TrackViewConcrete TrackViewConcrete; +typedef struct _TrackViewConcreteClass TrackViewConcreteClass; +#define _class_factory_unref0(var) ((var == NULL) ? NULL : (var = (class_factory_unref (var), NULL))) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +typedef struct _ParamSpecClassFactory ParamSpecClassFactory; + +struct _TrackViewIface { + GTypeInterface parent_iface; + void (*move_to_top) (TrackView* self, ClipView* clip_view); + void (*resize) (TrackView* self); + ModelTrack* (*get_track) (TrackView* self); + gint (*get_track_height) (TrackView* self); + GtkWidget* (*find_child) (TrackView* self, double x, double y); + void (*select_all) (TrackView* self); +}; + +struct _ClassFactory { + GTypeInstance parent_instance; + volatile int ref_count; + ClassFactoryPrivate * priv; +}; + +struct _ClassFactoryClass { + GTypeClass parent_class; + void (*finalize) (ClassFactory *self); + TrackView* (*get_track_view) (ClassFactory* self, ModelTrack* track, TimeLine* timeline); +}; + +struct _TransportDelegateIface { + GTypeInterface parent_iface; + gboolean (*is_playing) (TransportDelegate* self); + gboolean (*is_recording) (TransportDelegate* self); + gboolean (*is_stopped) (TransportDelegate* self); +}; + +struct _ParamSpecClassFactory { + GParamSpec parent_instance; +}; + + +static ClassFactory* class_factory_class_factory; +static ClassFactory* class_factory_class_factory = NULL; +static TransportDelegate* class_factory_transport_delegate; +static TransportDelegate* class_factory_transport_delegate = NULL; +static gpointer class_factory_parent_class = NULL; + +GType clip_view_get_type (void); +GType model_track_get_type (void); +GType track_view_get_type (void); +void track_view_move_to_top (TrackView* self, ClipView* clip_view); +void track_view_resize (TrackView* self); +ModelTrack* track_view_get_track (TrackView* self); +gint track_view_get_track_height (TrackView* self); +GtkWidget* track_view_find_child (TrackView* self, double x, double y); +void track_view_select_all (TrackView* self); +gpointer class_factory_ref (gpointer instance); +void class_factory_unref (gpointer instance); +GParamSpec* param_spec_class_factory (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); +void value_set_class_factory (GValue* value, gpointer v_object); +void value_take_class_factory (GValue* value, gpointer v_object); +gpointer value_get_class_factory (const GValue* value); +GType class_factory_get_type (void); +GType time_line_get_type (void); +enum { + CLASS_FACTORY_DUMMY_PROPERTY +}; +GType transport_delegate_get_type (void); +ClassFactory* class_factory_get_class_factory (void); +TrackViewConcrete* track_view_concrete_new (TransportDelegate* transport_delegate, ModelTrack* track, TimeLine* timeline); +TrackViewConcrete* track_view_concrete_construct (GType object_type, TransportDelegate* transport_delegate, ModelTrack* track, TimeLine* timeline); +GType track_view_concrete_get_type (void); +TrackView* class_factory_get_track_view (ClassFactory* self, ModelTrack* track, TimeLine* timeline); +static TrackView* class_factory_real_get_track_view (ClassFactory* self, ModelTrack* track, TimeLine* timeline); +void class_factory_set_class_factory (ClassFactory* class_factory); +void class_factory_set_transport_delegate (TransportDelegate* transport_delegate); +ClassFactory* class_factory_new (void); +ClassFactory* class_factory_construct (GType object_type); +static void class_factory_finalize (ClassFactory* obj); + + + +#line 9 "ClassFactory.vala" +void track_view_move_to_top (TrackView* self, ClipView* clip_view) { +#line 9 "ClassFactory.vala" + TRACK_VIEW_GET_INTERFACE (self)->move_to_top (self, clip_view); +#line 168 "ClassFactory.c" +} + + +#line 10 "ClassFactory.vala" +void track_view_resize (TrackView* self) { +#line 10 "ClassFactory.vala" + TRACK_VIEW_GET_INTERFACE (self)->resize (self); +#line 176 "ClassFactory.c" +} + + +#line 11 "ClassFactory.vala" +ModelTrack* track_view_get_track (TrackView* self) { +#line 11 "ClassFactory.vala" + return TRACK_VIEW_GET_INTERFACE (self)->get_track (self); +#line 184 "ClassFactory.c" +} + + +#line 12 "ClassFactory.vala" +gint track_view_get_track_height (TrackView* self) { +#line 12 "ClassFactory.vala" + return TRACK_VIEW_GET_INTERFACE (self)->get_track_height (self); +#line 192 "ClassFactory.c" +} + + +#line 13 "ClassFactory.vala" +GtkWidget* track_view_find_child (TrackView* self, double x, double y) { +#line 13 "ClassFactory.vala" + return TRACK_VIEW_GET_INTERFACE (self)->find_child (self, x, y); +#line 200 "ClassFactory.c" +} + + +#line 14 "ClassFactory.vala" +void track_view_select_all (TrackView* self) { +#line 14 "ClassFactory.vala" + TRACK_VIEW_GET_INTERFACE (self)->select_all (self); +#line 208 "ClassFactory.c" +} + + +static void track_view_base_init (TrackViewIface * iface) { + static gboolean initialized = FALSE; + if (!initialized) { + initialized = TRUE; + g_signal_new ("clip_view_added", TYPE_TRACK_VIEW, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, TYPE_CLIP_VIEW); + } +} + + +GType track_view_get_type (void) { + static volatile gsize track_view_type_id__volatile = 0; + if (g_once_init_enter (&track_view_type_id__volatile)) { + static const GTypeInfo g_define_type_info = { sizeof (TrackViewIface), (GBaseInitFunc) track_view_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL }; + GType track_view_type_id; + track_view_type_id = g_type_register_static (G_TYPE_INTERFACE, "TrackView", &g_define_type_info, 0); + g_type_interface_add_prerequisite (track_view_type_id, GTK_TYPE_WIDGET); + g_once_init_leave (&track_view_type_id__volatile, track_view_type_id); + } + return track_view_type_id__volatile; +} + + +static gpointer _class_factory_ref0 (gpointer self) { + return self ? class_factory_ref (self) : NULL; +} + + +#line 21 "ClassFactory.vala" +ClassFactory* class_factory_get_class_factory (void) { +#line 241 "ClassFactory.c" + ClassFactory* result = NULL; + result = _class_factory_ref0 (class_factory_class_factory); +#line 22 "ClassFactory.vala" + return result; +#line 246 "ClassFactory.c" +} + + +#line 25 "ClassFactory.vala" +static TrackView* class_factory_real_get_track_view (ClassFactory* self, ModelTrack* track, TimeLine* timeline) { +#line 252 "ClassFactory.c" + TrackView* result = NULL; +#line 25 "ClassFactory.vala" + g_return_val_if_fail (IS_CLASS_FACTORY (self), NULL); +#line 25 "ClassFactory.vala" + g_return_val_if_fail (MODEL_IS_TRACK (track), NULL); +#line 25 "ClassFactory.vala" + g_return_val_if_fail (IS_TIME_LINE (timeline), NULL); +#line 26 "ClassFactory.vala" + g_assert (class_factory_transport_delegate != NULL); +#line 262 "ClassFactory.c" + result = TRACK_VIEW (g_object_ref_sink (track_view_concrete_new (class_factory_transport_delegate, track, timeline))); +#line 27 "ClassFactory.vala" + return result; +#line 266 "ClassFactory.c" +} + + +#line 25 "ClassFactory.vala" +TrackView* class_factory_get_track_view (ClassFactory* self, ModelTrack* track, TimeLine* timeline) { +#line 25 "ClassFactory.vala" + return CLASS_FACTORY_GET_CLASS (self)->get_track_view (self, track, timeline); +#line 274 "ClassFactory.c" +} + + +#line 30 "ClassFactory.vala" +void class_factory_set_class_factory (ClassFactory* class_factory) { +#line 280 "ClassFactory.c" + ClassFactory* _tmp0_; +#line 30 "ClassFactory.vala" + g_return_if_fail (IS_CLASS_FACTORY (class_factory)); +#line 31 "ClassFactory.vala" + class_factory_class_factory = (_tmp0_ = _class_factory_ref0 (class_factory), _class_factory_unref0 (class_factory_class_factory), _tmp0_); +#line 286 "ClassFactory.c" +} + + +static gpointer _g_object_ref0 (gpointer self) { + return self ? g_object_ref (self) : NULL; +} + + +#line 34 "ClassFactory.vala" +void class_factory_set_transport_delegate (TransportDelegate* transport_delegate) { +#line 297 "ClassFactory.c" + TransportDelegate* _tmp0_; +#line 34 "ClassFactory.vala" + g_return_if_fail (IS_TRANSPORT_DELEGATE (transport_delegate)); +#line 35 "ClassFactory.vala" + class_factory_transport_delegate = (_tmp0_ = _g_object_ref0 (transport_delegate), _g_object_unref0 (class_factory_transport_delegate), _tmp0_); +#line 303 "ClassFactory.c" +} + + +#line 17 "ClassFactory.vala" +ClassFactory* class_factory_construct (GType object_type) { +#line 309 "ClassFactory.c" + ClassFactory* self; + self = (ClassFactory*) g_type_create_instance (object_type); + return self; +} + + +#line 17 "ClassFactory.vala" +ClassFactory* class_factory_new (void) { +#line 17 "ClassFactory.vala" + return class_factory_construct (TYPE_CLASS_FACTORY); +#line 320 "ClassFactory.c" +} + + +static void value_class_factory_init (GValue* value) { + value->data[0].v_pointer = NULL; +} + + +static void value_class_factory_free_value (GValue* value) { + if (value->data[0].v_pointer) { + class_factory_unref (value->data[0].v_pointer); + } +} + + +static void value_class_factory_copy_value (const GValue* src_value, GValue* dest_value) { + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = class_factory_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + + +static gpointer value_class_factory_peek_pointer (const GValue* value) { + return value->data[0].v_pointer; +} + + +static gchar* value_class_factory_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + if (collect_values[0].v_pointer) { + ClassFactory* object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = class_factory_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + + +static gchar* value_class_factory_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) { + ClassFactory** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = class_factory_ref (value->data[0].v_pointer); + } + return NULL; +} + + +GParamSpec* param_spec_class_factory (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) { + ParamSpecClassFactory* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_CLASS_FACTORY), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + + +gpointer value_get_class_factory (const GValue* value) { + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_CLASS_FACTORY), NULL); + return value->data[0].v_pointer; +} + + +void value_set_class_factory (GValue* value, gpointer v_object) { + ClassFactory* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_CLASS_FACTORY)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_CLASS_FACTORY)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + class_factory_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + class_factory_unref (old); + } +} + + +void value_take_class_factory (GValue* value, gpointer v_object) { + ClassFactory* old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_CLASS_FACTORY)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_CLASS_FACTORY)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + class_factory_unref (old); + } +} + + +static void class_factory_class_init (ClassFactoryClass * klass) { + class_factory_parent_class = g_type_class_peek_parent (klass); + CLASS_FACTORY_CLASS (klass)->finalize = class_factory_finalize; + CLASS_FACTORY_CLASS (klass)->get_track_view = class_factory_real_get_track_view; +} + + +static void class_factory_instance_init (ClassFactory * self) { + self->ref_count = 1; +} + + +static void class_factory_finalize (ClassFactory* obj) { + ClassFactory * self; + self = CLASS_FACTORY (obj); +} + + +GType class_factory_get_type (void) { + static volatile gsize class_factory_type_id__volatile = 0; + if (g_once_init_enter (&class_factory_type_id__volatile)) { + static const GTypeValueTable g_define_type_value_table = { value_class_factory_init, value_class_factory_free_value, value_class_factory_copy_value, value_class_factory_peek_pointer, "p", value_class_factory_collect_value, "p", value_class_factory_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (ClassFactoryClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) class_factory_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ClassFactory), 0, (GInstanceInitFunc) class_factory_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType class_factory_type_id; + class_factory_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ClassFactory", &g_define_type_info, &g_define_type_fundamental_info, 0); + g_once_init_leave (&class_factory_type_id__volatile, class_factory_type_id); + } + return class_factory_type_id__volatile; +} + + +gpointer class_factory_ref (gpointer instance) { + ClassFactory* self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + + +void class_factory_unref (gpointer instance) { + ClassFactory* self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + CLASS_FACTORY_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + + + +