]> git.datanom.net - gtk_lensdatabase.git/blobdiff - src/lensmaker.c
On the way
[gtk_lensdatabase.git] / src / lensmaker.c
index 71378e37b884978be639ca0ca26a82387dd9e9a7..f21712b87ba6e5b4da71f0814c1f7041216264ed 100644 (file)
 
 #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;
 }
This page took 0.232787 seconds and 5 git commands to generate.