]> git.datanom.net - gtk_lensdatabase.git/blobdiff - src/lens.c
On the way
[gtk_lensdatabase.git] / src / lens.c
index 32693b29afa0fe48781cb86b9b1cef37b5287795..83f2e6efcd17b4cba1c21d5cd3c1adf578e7ca57 100644 (file)
  */
 
 #include "lens.h"
+#include <glib.h>
 
-struct _LensPrivate
-{
-  /* add your private declarations here */
-  gpointer delete_me;
+enum {
+  PROP_ID = 1,
+  PROP_SN,
+  PROP_DATA,
+  PROP_NOTES,
+  PROP_DATE,
+  N_PROPERTIES
 };
 
+static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, };
 static void lens_finalize (GObject *object);
+static void lens_dispose (GObject *gobject);
 
-G_DEFINE_TYPE (Lens, lens, G_TYPE_OBJECT)
+typedef struct {
+       /* add your private declarations here */
+       gint id;
+       gchar* sn;
+       gchar* data;
+       gchar* notes;
+       gchar* date;
+       GList* lens;
+} LensPrivate;
 
+struct _Lens {
+  GObject parent;
+  /* add your public declarations here */
+};
+
+G_DEFINE_TYPE_WITH_PRIVATE(Lens, lens, G_TYPE_OBJECT)
+
+static void lens_set_property (        GObject      *object,
+                                                               guint         prop_id,
+                                                               const GValue *value,
+                                                               GParamSpec   *pspec) {
+       LensPrivate *priv = lens_get_instance_private(LENS (object));
+
+       switch (prop_id) {
+               case PROP_ID:
+                       priv->id = g_value_get_int (value);
+                       break;
+               case PROP_SN:
+                       if (priv->sn)
+                               g_free(priv->sn);
+                       priv->sn = g_strdup(g_value_get_string (value));
+                       break;
+               case PROP_DATA:
+                       if (priv->data)
+                               g_free(priv->data);
+                       priv->data = g_strdup(g_value_get_string (value));
+                       break;
+               case PROP_NOTES:
+                       if (priv->notes)
+                               g_free(priv->notes);
+                       priv->notes = g_strdup(g_value_get_string (value));
+                       break;
+               case PROP_DATE:
+                       if (priv->date)
+                               g_free(priv->date);
+                       priv->date = g_strdup(g_value_get_string (value));
+                       break;
+               
+               default:
+                       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+                       break;
+       }
+}
+
+static void lens_get_property (        GObject    *object,
+                                                               guint       prop_id,
+                                                               GValue     *value,
+                                                               GParamSpec *pspec) {
+       LensPrivate *priv = lens_get_instance_private(LENS (object));
+
+       switch (prop_id) {
+               case PROP_ID:
+                       g_value_set_int (value, priv->id);
+                       break;
+               case PROP_SN:
+                       g_value_set_string (value, priv->sn);
+                       break;
+               case PROP_DATA:
+                       g_value_set_string (value, priv->data);
+                       break;
+               case PROP_NOTES:
+                       g_value_set_string (value, priv->notes);
+                       break;
+               case PROP_DATE:
+                       g_value_set_string (value, priv->date);
+                       break;
+               
+               default:
+                       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+                       break;
+       }
+}
+
+static void lens_class_init (LensClass *klass) {
+       GObjectClass *g_object_class;
+
+       g_object_class = G_OBJECT_CLASS (klass);
+
+       g_object_class->dispose = lens_dispose;
+       g_object_class->finalize = lens_finalize;
+
+       g_object_class->set_property = lens_set_property;
+       g_object_class->get_property = lens_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_SN] =
+       g_param_spec_string ("sn",
+                                                "SerialNumber",
+                                                "Serial Number of the lens.",
+                                                NULL  /* default value */,
+                                                G_PARAM_READWRITE);
+       obj_properties[PROP_DATA] =
+       g_param_spec_string ("data",
+                                                "Data",
+                                                "Lens description.",
+                                                NULL  /* default value */,
+                                                G_PARAM_READWRITE);
+       obj_properties[PROP_NOTES] =
+       g_param_spec_string ("notes",
+                                                "Notes",
+                                                "Lens notes.",
+                                                NULL  /* default value */,
+                                                G_PARAM_READWRITE);
+       obj_properties[PROP_DATE] =
+       g_param_spec_string ("date",
+                                                "Date",
+                                                "Date the lens was added.",
+                                                NULL  /* default value */,
+                                                G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
+
+       g_object_class_install_properties (g_object_class,
+                                                                          N_PROPERTIES,
+                                                                          obj_properties);
+}
+
+static void lens_dispose (GObject *gobject) {
+       //LensPrivate *priv = lens_get_instance_private(LENS(gobject));
 
-static void
-lens_class_init (LensClass *klass)
-{
-  GObjectClass *g_object_class;
+       /* 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.
+       */
 
-  g_object_class = G_OBJECT_CLASS (klass);
+       /* 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);
+       */
 
-  g_object_class->finalize = lens_finalize;
+       /* 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_parent_class)->dispose (gobject);
+}
+
+static void lens_finalize (GObject *object) {
+       Lens *self;
+
+       g_return_if_fail (IS_LENS (object));
+
+       self = LENS (object);
 
-  g_type_class_add_private ((gpointer)klass, sizeof (LensPrivate));
+       LensPrivate *priv = lens_get_instance_private(self);
+       g_free(priv->data);
+       g_free(priv->date);
+       g_free(priv->sn);
+       g_free(priv->notes);
+       
+       G_OBJECT_CLASS (lens_parent_class)->finalize (object);
 }
 
 
-static void
-lens_finalize (GObject *object)
-{
-  Lens *self;
+static void lens_init (Lens *self) {
+       LensPrivate *priv = lens_get_instance_private(self);
+       priv->data = NULL;
+       priv->date = NULL;
+       priv->sn = NULL;
+       priv->notes = NULL;;
+}
+
+
+Lens *lens_new (gint id, const gchar* sn, const gchar* data, GError** error) {
+       g_return_val_if_fail (sn == NULL || data == NULL || error == NULL || *error == NULL, NULL);
+
+       gchar* now = get_current_timestamp();
+       Lens* lens = LENS(g_object_new (TYPE_LENS, "id", id, "sn", sn, "data", data, "date", now, NULL));
+       g_free(now);
+       return lens;
+}
+
+gchar* get_current_timestamp() {
+       GDateTime* dt = g_date_time_new_now_local();
+       gchar* now = g_date_time_format (dt, "%Y-%m-%d %H:%M:%S");
+       g_date_time_unref(dt);
+               
+       return now;
+}
 
-  g_return_if_fail (IS_LENS (object));
+void lens_set_sn(Lens* self, const gchar* sn, GError** error) {
+       g_return_if_fail (IS_LENS (self));
+       g_return_if_fail (sn == NULL || error == NULL || *error == NULL);
+       
+       LensPrivate *priv = lens_get_instance_private(self);
+       if (priv->sn)
+               g_free(priv->sn);
+       priv->sn = g_strdup(sn);
+}
 
-  self = LENS (object);
+void lens_set_data(Lens* self, const gchar* data, GError** error) {
+       g_return_if_fail (IS_LENS (self));
+       g_return_if_fail (data == NULL || error == NULL || *error == NULL);
+       
+       LensPrivate *priv = lens_get_instance_private(self);
+       if (priv->data)
+               g_free(priv->data);
+       priv->data = g_strdup(data);
+}
 
-  G_OBJECT_CLASS (lens_parent_class)->finalize (object);
+void lens_set_notes(Lens* self, const gchar* notes, GError** error) {
+       g_return_if_fail (IS_LENS (self));
+       g_return_if_fail (notes == NULL || error == NULL || *error == NULL);
+       
+       LensPrivate *priv = lens_get_instance_private(self);
+       if (priv->notes)
+               g_free(priv->notes);
+       priv->notes = g_strdup(notes);
 }
 
+void lens_set_date(Lens* self, const gchar* date, GError** error) {
+       g_return_if_fail (IS_LENS (self));
+       g_return_if_fail (date == NULL || error == NULL || *error == NULL);
+       
+       LensPrivate *priv = lens_get_instance_private(self);
+       if (priv->date)
+               g_free(priv->date);
+       priv->date = g_strdup(date);
+}
 
-static void
-lens_init (Lens *self)
-{
-  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, TYPE_LENS, LensPrivate);
+gint lens_get_id(Lens* self, GError** error) {
+       g_return_val_if_fail (IS_LENS (self), -1);
+       g_return_val_if_fail (error == NULL || *error == NULL, -1);
+       
+       LensPrivate *priv = lens_get_instance_private(self);
+       
+       return priv->id;
 }
 
+gchar* lens_to_string(Lens* self) {
+       g_return_val_if_fail (IS_LENS (self), NULL);
+       
+       gchar* data;
+       gchar* date;
+       gchar* sn;
+       gchar* notes;
+       gint id;
+       
+       g_object_get(self, "id", &id, "data", &data, "date", &date, "sn", &sn, "notes", &notes, NULL);
+       
+       gchar* s = g_strdup_printf("[%d [%s:%s:%s - %s]]", id, sn, data, notes, date);
+       g_free(data);
+       g_free(date);
+       g_free(sn);
+       g_free(notes);
+
+       return s;
+}
 
-GObject *
-lens_new (void)
-{
-  return g_object_new (TYPE_LENS, NULL);
+Lens* lens_get_copy(const Lens* self, GError** error) {
+       g_return_val_if_fail (IS_LENS (self), NULL);
+       g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+       
+       LensPrivate *priv = lens_get_instance_private((Lens*)self);
+       
+       Lens* lens = lens_new(priv->id, priv->sn, priv->data, error);
+       if (*error) {
+               g_object_unref(lens);
+               return NULL;
+       }
+       g_object_set(lens, "notes", priv->notes, "date", priv->date, NULL);
+       
+       return lens;
 }
This page took 0.237363 seconds and 5 git commands to generate.