/* * lensmaker.c * * Copyright 2024 Michael Rasmussen * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, * MA 02110-1301, USA. * * */ #include "lensmaker.h" 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); } 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; g_return_if_fail (IS_LENS_MAKER (object)); self = LENS_MAKER (object); 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); } 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; } LensMaker *lens_maker_new (gint id) { return LENS_MAKER(g_object_new (TYPE_LENS_MAKER, "id", id, NULL)); } 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; } 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); 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); 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; } 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; }