adg/adg-model.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007-2008, Nicola Fontana <ntd at entidi.it>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA  02111-1307, USA.
  18  */
  19
  20
  21 /**
  22  * SECTION:model
  23  * @title: AdgModel
  24  * @short_description: The data model
  25  *
  26  * Every drawing is a representation of a part: the #AdgModel contains all the
  27  * data needed by the drawing (overall, quotes).
  28  *
  29  * Because the #AdgModel instances are only a data collection, they are not
  30  * renderable, so the class is not derived from #AdgEntity.
  31  */
  32
  33 #include "adg-model.h"
  34 #include "adg-model-private.h"
  35 #include "adg-intl.h"
  36
  37 #define PARENT_CLASS ((GObjectClass *) adg_model_parent_class)
  38
  39
  40 enum {
  41     PROP_0,
  42     PROP_NAME,
  43     PROP_MATERIAL,
  44     PROP_TREATMENT
  45 };
  46
  47 enum {
  48     MODIFIED,
  49     LAST_SIGNAL
  50 };
  51
  52
  53 static void     finalize                (GObject        *object);
  54 static void     get_property            (GObject        *object,
  55                                          guint           prop_id,
  56                                          GValue         *value,
  57                                          GParamSpec     *pspec);
  58 static void     set_property            (GObject        *object,
  59                                          guint           prop_id,
  60                                          const GValue   *value,
  61                                          GParamSpec     *pspec);
  62 static void     set_name                (AdgModel       *model,
  63                                          const gchar    *name);
  64 static void     set_material            (AdgModel       *model,
  65                                          const gchar    *material);
  66 static void     set_treatment           (AdgModel       *model,
  67                                          const gchar    *treatment);
  68
  69 static guint model_signals[LAST_SIGNAL] = { 0 };
  70
  71
  72 G_DEFINE_TYPE(AdgModel, adg_model, G_TYPE_OBJECT);
  73
  74
  75 static void
  76 adg_model_class_init(AdgModelClass *klass)
  77 {
  78     GObjectClass *gobject_class;
  79     GParamSpec *param;
  80
  81     gobject_class = (GObjectClass *) klass;
  82
  83     g_type_class_add_private(klass, sizeof(AdgModelPrivate));
  84
  85     gobject_class->set_property = set_property;
  86     gobject_class->get_property = get_property;
  87     gobject_class->finalize = finalize;
  88
  89     param = g_param_spec_string("name",
  90                                 P_("Part Name"),
  91                                 P_("Descriptive name of this part"),
  92                                 NULL, G_PARAM_READWRITE);
  93     g_object_class_install_property(gobject_class, PROP_NAME, param);
  94
  95     param = g_param_spec_string("material",
  96                                 P_("Material"),
  97                                 P_("Material this part is done with"),
  98                                 NULL, G_PARAM_READWRITE);
  99     g_object_class_install_property(gobject_class, PROP_MATERIAL, param);
 100
 101     param = g_param_spec_string("treatment",
 102                                 P_("Treatment"),
 103                                 P_("Treatment this part must receive"),
 104                                 NULL, G_PARAM_READWRITE);
 105     g_object_class_install_property(gobject_class, PROP_TREATMENT, param);
 106 }
 107
 108 static void
 109 adg_model_init(AdgModel *model)
 110 {
 111     AdgModelPrivate *priv =
 112         G_TYPE_INSTANCE_GET_PRIVATE(model, ADG_TYPE_MODEL,
 113                                     AdgModelPrivate);
 114     priv->name = NULL;
 115     priv->material = NULL;
 116     priv->treatment = NULL;
 117
 118     model->priv = priv;
 119 }
 120
 121 static void
 122 finalize(GObject *object)
 123 {
 124     AdgModel *model = (AdgModel *) object;
 125
 126     g_free(model->priv->name);
 127     g_free(model->priv->material);
 128     g_free(model->priv->treatment);
 129
 130     PARENT_CLASS->finalize(object);
 131 }
 132
 133
 134 static void
 135 get_property(GObject *object,
 136              guint prop_id, GValue *value, GParamSpec *pspec)
 137 {
 138     AdgModelPrivate *priv = ((AdgModel *) object)->priv;
 139
 140     switch (prop_id) {
 141     case PROP_NAME:
 142         g_value_set_string(value, priv->name);
 143         break;
 144     case PROP_MATERIAL:
 145         g_value_set_string(value, priv->material);
 146         break;
 147     case PROP_TREATMENT:
 148         g_value_set_string(value, priv->treatment);
 149         break;
 150     default:
 151         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 152         break;
 153     }
 154 }
 155
 156 static void
 157 set_property(GObject *object,
 158              guint prop_id, const GValue *value, GParamSpec *pspec)
 159 {
 160     AdgModel *model = ADG_MODEL(object);
 161
 162     switch (prop_id) {
 163     case PROP_NAME:
 164         set_name(model, g_value_get_string(value));
 165         break;
 166     case PROP_MATERIAL:
 167         set_material(model, g_value_get_string(value));
 168         break;
 169     case PROP_TREATMENT:
 170         set_treatment(model, g_value_get_string(value));
 171         break;
 172     default:
 173         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 174         break;
 175     }
 176 }
 177
 178
 179 gchar *
 180 adg_model_get_name(AdgModel *model)
 181 {
 182     g_return_val_if_fail(ADG_IS_MODEL(model), NULL);
 183
 184     return g_strdup(model->priv->name);
 185 }
 186
 187 void
 188 adg_model_set_name(AdgModel *model, const gchar *name)
 189 {
 190     g_return_if_fail(ADG_IS_MODEL(model));
 191
 192     set_name(model, name);
 193     g_object_notify((GObject *) model, "name");
 194 }
 195
 196
 197 gchar *
 198 adg_model_get_material(AdgModel *model)
 199 {
 200     g_return_val_if_fail(ADG_IS_MODEL(model), NULL);
 201
 202     return g_strdup(model->priv->material);
 203 }
 204
 205 void
 206 adg_model_set_material(AdgModel *model, const gchar *material)
 207 {
 208     g_return_if_fail(ADG_IS_MODEL(model));
 209
 210     set_material(model, material);
 211     g_object_notify((GObject *) model, "material");
 212 }
 213
 214
 215 gchar *
 216 adg_model_get_treatment(AdgModel *model)
 217 {
 218     g_return_val_if_fail(ADG_IS_MODEL(model), NULL);
 219
 220     return g_strdup(model->priv->treatment);
 221 }
 222
 223 void
 224 adg_model_set_treatment(AdgModel *model, const gchar *treatment)
 225 {
 226     g_return_if_fail(ADG_IS_MODEL(model));
 227
 228     set_treatment(model, treatment);
 229     g_object_notify((GObject *) model, "treatment");
 230 }
 231
 232 static void
 233 set_name(AdgModel *model, const gchar *name)
 234 {
 235     g_free(model->priv->name);
 236     model->priv->name = g_strdup(name);
 237 }
 238
 239 static void
 240 set_material(AdgModel *model, const gchar *material)
 241 {
 242     g_free(model->priv->material);
 243     model->priv->material = g_strdup(material);
 244 }
 245
 246 static void
 247 set_treatment(AdgModel *model, const gchar *treatment)
 248 {
 249     g_free(model->priv->treatment);
 250     model->priv->treatment = g_strdup(treatment);
 251 }