plugins/class-gen/validator.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*  validator.c
   3  *      Copyright (C) 2006 Armin Burgmeier
   4  *
   5  *      This program is free software; you can redistribute it and/or modify
   6  *      it under the terms of the GNU General Public License as published by
   7  *      the Free Software Foundation; either version 2 of the License, or
   8  *      (at your option) any later version.
   9  *
  10  *      This program is distributed in the hope that it will be useful,
  11  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.    See the
  13  *      GNU Library General Public License for more details.
  14  *
  15  *      You should have received a copy of the GNU General Public License
  16  *      along with this program; if not, write to the Free Software
  17  *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  */
  19
  20 #include "validator.h"
  21
  22 #include <gtk/gtkentry.h>
  23
  24 typedef struct _CgValidatorPrivate CgValidatorPrivate;
  25 struct _CgValidatorPrivate
  26 {
  27         GtkWidget *widget;
  28         GSList *entry_list;
  29 };
  30
  31 #define CG_VALIDATOR_PRIVATE(o) \
  32         (G_TYPE_INSTANCE_GET_PRIVATE( \
  33                 (o), \
  34                 CG_TYPE_VALIDATOR, \
  35                 CgValidatorPrivate \
  36         ))
  37
  38 enum {
  39         PROP_0,
  40
  41         /* Construct only */
  42         PROP_WIDGET
  43 };
  44
  45 static GObjectClass *parent_class = NULL;
  46
  47 static void
  48 cg_validator_entry_changed_cb (GtkEntry *entry,
  49                                gpointer user_data)
  50 {
  51         CgValidator *validator;
  52         validator = CG_VALIDATOR (user_data);
  53
  54         cg_validator_revalidate (validator);
  55 }
  56
  57 static void
  58 cg_validator_init (CgValidator *validator)
  59 {
  60         CgValidatorPrivate *priv;
  61         priv = CG_VALIDATOR_PRIVATE (validator);
  62
  63         priv->widget = NULL;
  64         priv->entry_list = NULL;
  65 }
  66
  67 static void
  68 cg_validator_finalize (GObject *object)
  69 {
  70         CgValidator *validator;
  71         CgValidatorPrivate *priv;
  72         GSList *item;
  73
  74         validator = CG_VALIDATOR (object);
  75         priv = CG_VALIDATOR_PRIVATE (validator);
  76
  77         for (item = priv->entry_list; item != NULL; item = item->next)
  78         {
  79                 g_signal_handlers_disconnect_by_func (
  80                         G_OBJECT (item->data), G_CALLBACK (cg_validator_entry_changed_cb),
  81                         validator);
  82         }
  83
  84         g_slist_free (priv->entry_list);
  85         priv->entry_list = NULL;
  86
  87         G_OBJECT_CLASS (parent_class)->finalize (object);
  88 }
  89
  90 static void
  91 cg_validator_set_property (GObject *object,
  92                            guint prop_id,
  93                            const GValue *value,
  94                            GParamSpec *pspec)
  95 {
  96         CgValidator *validator;
  97         CgValidatorPrivate *priv;
  98
  99         g_return_if_fail (CG_IS_VALIDATOR (object));
 100
 101         validator = CG_VALIDATOR (object);
 102         priv = CG_VALIDATOR_PRIVATE (validator);
 103
 104         switch (prop_id)
 105         {
 106         case PROP_WIDGET:
 107                 priv->widget = GTK_WIDGET (g_value_get_object (value));
 108                 break;
 109         default:
 110                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 111                 break;
 112         }
 113 }
 114
 115 static void
 116 cg_validator_get_property (GObject *object,
 117                            guint prop_id,
 118                            GValue *value,
 119                            GParamSpec *pspec)
 120 {
 121         CgValidator* validator;
 122         CgValidatorPrivate* priv;
 123
 124         g_return_if_fail(CG_IS_VALIDATOR(object));
 125
 126         validator = CG_VALIDATOR(object);
 127         priv = CG_VALIDATOR_PRIVATE(validator);
 128
 129         switch(prop_id)
 130         {
 131         case PROP_WIDGET:
 132                 g_value_set_object(value, G_OBJECT(priv->widget));
 133                 break;
 134         default:
 135                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 136                 break;
 137         }
 138 }
 139
 140 static void
 141 cg_validator_class_init (CgValidatorClass* klass)
 142 {
 143         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 144         parent_class = g_type_class_peek_parent (klass);
 145
 146         g_type_class_add_private (klass, sizeof (CgValidatorPrivate));
 147
 148         object_class->finalize = cg_validator_finalize;
 149         object_class->set_property = cg_validator_set_property;
 150         object_class->get_property = cg_validator_get_property;
 151
 152         g_object_class_install_property (object_class,
 153                                          PROP_WIDGET,
 154                                          g_param_spec_object ("widget",
 155                                                               "Widget",
 156                                                               "Widget to make insensitive if the entries are empty",
 157                                                               GTK_TYPE_WIDGET,
 158                                                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 159 }
 160
 161 GType
 162 cg_validator_get_type (void)
 163 {
 164         static GType our_type = 0;
 165
 166         if(our_type == 0)
 167         {
 168                 static const GTypeInfo our_info =
 169                 {
 170                         sizeof (CgValidatorClass),
 171                         (GBaseInitFunc) NULL,
 172                         (GBaseFinalizeFunc) NULL,
 173                         (GClassInitFunc) cg_validator_class_init,
 174                         NULL,
 175                         NULL,
 176                         sizeof (CgValidator),
 177                         0,
 178                         (GInstanceInitFunc) cg_validator_init,
 179                         NULL
 180                 };
 181
 182                 our_type = g_type_register_static (G_TYPE_OBJECT, "CgValidator",
 183                                                    &our_info, 0);
 184         }
 185
 186         return our_type;
 187 }
 188
 189 CgValidator *
 190 cg_validator_new (GtkWidget *widget,
 191                   ...)
 192 {
 193         CgValidator *validator;
 194         CgValidatorPrivate *priv;
 195         GtkEntry *entry;
 196         va_list arglist;
 197
 198         validator = CG_VALIDATOR (g_object_new (CG_TYPE_VALIDATOR, "widget",
 199                                                 widget, NULL));
 200
 201         priv = CG_VALIDATOR_PRIVATE (validator);
 202
 203         va_start (arglist, widget);
 204         entry = va_arg (arglist, GtkEntry *);
 205         while (entry != NULL)
 206         {
 207                 g_signal_connect (G_OBJECT (entry), "changed",
 208                                   G_CALLBACK (cg_validator_entry_changed_cb),
 209                                   validator);
 210
 211                 priv->entry_list = g_slist_prepend (priv->entry_list, entry);
 212                 entry = va_arg (arglist, GtkEntry *);
 213         }
 214
 215         cg_validator_revalidate (validator);
 216         return validator;
 217 }
 218
 219 void
 220 cg_validator_revalidate (CgValidator *validator)
 221 {
 222         CgValidatorPrivate *priv;
 223         GtkEntry *entry;
 224         GSList *item;
 225         gchar *text;
 226
 227         priv = CG_VALIDATOR_PRIVATE (validator);
 228         for (item = priv->entry_list; item != NULL; item = item->next)
 229         {
 230                 entry = GTK_ENTRY (item->data);
 231                 text = g_strdup (gtk_entry_get_text (entry));
 232                 g_strchomp (text);
 233                 if (*text == '\0') break;
 234         }
 235
 236         if (item == NULL)
 237                 gtk_widget_set_sensitive (priv->widget, TRUE);
 238         else
 239                 gtk_widget_set_sensitive (priv->widget, FALSE);
 240 }