X-Git-Url: http://git.datanom.net/gtk_lensdatabase.git/blobdiff_plain/b579f6168df36c9cb62de1c1c21ce595fd5e1165..refs/heads/master:/src/lensmaker.c diff --git a/src/lensmaker.c b/src/lensmaker.c index 71378e3..f21712b 100644 --- a/src/lensmaker.c +++ b/src/lensmaker.c @@ -23,52 +23,232 @@ #include "lensmaker.h" -struct _LensMakerPrivate -{ - /* add your private declarations here */ - gpointer delete_me; +enum { + PROP_ID = 1, + PROP_NAME, + N_PROPERTIES }; +static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, }; static void lens_maker_finalize (GObject *object); +static void lens_maker_dispose (GObject *gobject); + +typedef struct { + /* add your private declarations here */ + gint id; + gchar* name; + GList* lens; +} LensMakerPrivate; + +struct _LensMaker { + GObject parent; + /* add your public declarations here */ + LensMakerPrivate *priv; +}; + +G_DEFINE_TYPE_WITH_PRIVATE(LensMaker, lens_maker, G_TYPE_OBJECT) + +static void lens_maker_set_property ( GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) { + LensMakerPrivate *priv = lens_maker_get_instance_private(LENS_MAKER (object)); + + switch (prop_id) { + case PROP_ID: + priv->id = g_value_get_int (value); + break; + case PROP_NAME: + if (priv->name) + g_free(priv->name); + priv->name = g_strdup(g_value_get_string (value)); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void lens_maker_get_property ( GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) { + LensMakerPrivate *priv = lens_maker_get_instance_private(LENS_MAKER (object)); + + switch (prop_id) { + case PROP_ID: + g_value_set_int (value, priv->id); + break; + case PROP_NAME: + g_value_set_string (value, priv->name); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void lens_maker_class_init (LensMakerClass *klass) { + GObjectClass *g_object_class; + + g_object_class = G_OBJECT_CLASS (klass); + + g_object_class->dispose = lens_maker_dispose; + g_object_class->finalize = lens_maker_finalize; + + g_object_class->set_property = lens_maker_set_property; + g_object_class->get_property = lens_maker_get_property; + + obj_properties[PROP_ID] = + g_param_spec_int ("id", + "Id", + "Database id.", + G_MININT, + G_MAXINT, + 0, + G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE); + obj_properties[PROP_NAME] = + g_param_spec_string ("lensmaker", + "LensMaker", + "Lens maker of the lens.", + NULL /* default value */, + G_PARAM_READWRITE); + + g_object_class_install_properties (g_object_class, + N_PROPERTIES, + obj_properties); +} + +static void lens_maker_dispose (GObject *gobject) { + //LensMakerPrivate *priv = lens_maker_get_instance_private(LENS_MAKER(gobject)); + + /* In dispose(), you are supposed to free all types referenced from this + * object which might themselves hold a reference to self. Generally, + * the most simple solution is to unref all members on which you own a + * reference. + */ + + /* dispose() might be called multiple times, so we must guard against + * calling g_object_unref() on an invalid GObject by setting the member + * NULL; g_clear_object() does this for us. + * g_clear_object (&priv->input_stream); + */ + + /* Always chain up to the parent class; there is no need to check if + * the parent class implements the dispose() virtual function: it is + * always guaranteed to do so + */ + G_OBJECT_CLASS(lens_maker_parent_class)->dispose (gobject); +} -G_DEFINE_TYPE (LensMaker, lens_maker, G_TYPE_OBJECT) +static void free_glist_items(gpointer data, gpointer user_data) { + if (data) { + Lens* lens = LENS(data); + g_object_unref(lens); + } +} +static void lens_maker_finalize (GObject *object) { + LensMaker *self; -static void -lens_maker_class_init (LensMakerClass *klass) -{ - GObjectClass *g_object_class; + g_return_if_fail (IS_LENS_MAKER (object)); - g_object_class = G_OBJECT_CLASS (klass); + self = LENS_MAKER (object); - g_object_class->finalize = lens_maker_finalize; + LensMakerPrivate *priv = lens_maker_get_instance_private(self); + g_free(priv->name); + g_list_foreach(priv->lens, (GFunc)free_glist_items, NULL); + g_list_free(priv->lens); + + G_OBJECT_CLASS (lens_maker_parent_class)->finalize (object); +} - g_type_class_add_private ((gpointer)klass, sizeof (LensMakerPrivate)); +static void lens_maker_init (LensMaker *self) { + LensMakerPrivate *priv = lens_maker_get_instance_private(self); + priv->name = NULL; + priv->lens = NULL; } +static gpointer copy_list(gconstpointer src, gpointer data) { + Lens* lens = lens_get_copy(LENS(src), (GError**) data); + return lens; +} -static void -lens_maker_finalize (GObject *object) -{ - LensMaker *self; +LensMaker *lens_maker_new (gint id) { + return LENS_MAKER(g_object_new (TYPE_LENS_MAKER, "id", id, NULL)); +} - g_return_if_fail (IS_LENS_MAKER (object)); +gint lens_maker_get_id(LensMaker* self) { + g_return_val_if_fail (IS_LENS_MAKER (self), -1); + LensMakerPrivate *priv = lens_maker_get_instance_private(self); + return priv->id; +} - self = LENS_MAKER (object); +void lens_maker_set_name(LensMaker* self, const gchar* name, GError** error) { + g_return_if_fail (IS_LENS_MAKER (self) || name != NULL || error == NULL || *error == NULL); - G_OBJECT_CLASS (lens_maker_parent_class)->finalize (object); + LensMakerPrivate *priv = lens_maker_get_instance_private(self); + g_free(priv->name); + priv->name = g_strdup(name); } +void lens_maker_add_lens(LensMaker* self, const Lens* lens, GError** error) { + g_return_if_fail (IS_LENS_MAKER (self) || lens != NULL || error == NULL || *error == NULL); -static void -lens_maker_init (LensMaker *self) -{ - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, TYPE_LENS_MAKER, LensMakerPrivate); + LensMakerPrivate *priv = lens_maker_get_instance_private(self); + Lens* l = lens_get_copy(lens, error); + if (!*error) + priv->lens = g_list_append(priv->lens, l); } +void lens_maker_remove_lens(LensMaker* self, Lens* lens, GError** error) { + g_return_if_fail (IS_LENS_MAKER (self) || lens != NULL || error == NULL || *error == NULL); + + LensMakerPrivate *priv = lens_maker_get_instance_private(self); + priv->lens = g_list_remove_all(priv->lens, lens); + g_object_unref(lens); +} + +Lens* lens_maker_get_lens(LensMaker* self, gint id, GError** error) { + g_return_val_if_fail (IS_LENS_MAKER (self) || id >= 0 || error == NULL || *error == NULL, NULL); + + LensMakerPrivate *priv = lens_maker_get_instance_private(self); + Lens* lens = NULL; + gint needle; + GList* iter = priv->lens; + while (iter) { + lens = iter->data; + g_object_get(lens, "id", &needle, NULL); + + if (id == needle) + break; + else + lens = NULL; + + iter = iter->next; + } + + Lens* l = lens_get_copy(lens, error); + if (*error) + return NULL; + else + return l; +} -GObject * -lens_maker_new (void) -{ - return g_object_new (TYPE_LENS_MAKER, NULL); +LensMaker* lens_maker_get_copy(const LensMaker* self, GError** error) { + g_return_val_if_fail (IS_LENS_MAKER (self) || error == NULL || *error == NULL, NULL); + + LensMakerPrivate *priv = lens_maker_get_instance_private((LensMaker*)self); + LensMaker* lens_maker = lens_maker_new(priv->id); + g_object_set(lens_maker, "lensmaker", priv->name, NULL); + LensMakerPrivate *newpriv = lens_maker_get_instance_private(lens_maker); + newpriv->lens = g_list_copy_deep(priv->lens, copy_list, error); + if (*error) { + g_object_unref(lens_maker); + return NULL; + } + + return lens_maker; }