plugins/profiler/gprof-options.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * gprof-options.c
   4  * Copyright (C) James Liggett 2007 <jrliggett@cox.net>
   5  *
   6  * gprof-options.c is free software.
   7  *
   8  * You may redistribute it and/or modify it under the terms of the
   9  * GNU General Public License, as published by the Free Software
  10  * Foundation; either version 2, or (at your option) any later version.
  11  *
  12  * plugin.c is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  15  * See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with plugin.c.  See the file "COPYING".  If not,
  19  * write to:  The Free Software Foundation, Inc.,
  20  *            51 Franklin Street, Fifth Floor,
  21  *            Boston,  MA  02110-1301, USA.
  22  */
  23
  24 #include "gprof-options.h"
  25
  26 /* Internal structure to hold information on individual preference keys */
  27 typedef struct
  28 {
  29         gchar *name;
  30         gchar *widget_name;
  31         GProfOptions *options;  /* Need this to set/get data from callbacks */
  32         OptionWidgetType widget_type;
  33 } Key;
  34
  35 struct _GProfOptionsPriv
  36 {
  37         GHashTable *default_options;
  38         GHashTable *targets;
  39         GHashTable *current_target;
  40         GHashTable *key_data_table;
  41 };
  42
  43 static void
  44 free_key (Key *key)
  45 {
  46         g_free (key->name);
  47         g_free (key->widget_name);
  48         g_free (key);
  49 }
  50
  51 static void
  52 gprof_options_init (GProfOptions *self)
  53 {
  54         self->priv = g_new0 (GProfOptionsPriv, 1);
  55
  56         self->priv->default_options = g_hash_table_new_full (g_str_hash,
  57                                                                                                                  g_str_equal,
  58                                                                                                                  g_free, g_free);
  59
  60         self->priv->key_data_table = g_hash_table_new_full (g_str_hash,
  61                                                                                                                 g_str_equal,
  62                                                                                                                 g_free,
  63                                                                                                                 (GDestroyNotify) free_key);
  64
  65         self->priv->targets = g_hash_table_new_full (g_str_hash,
  66                                                                                                  g_str_equal,
  67                                                                                                  g_free,
  68                                                                                                  (GDestroyNotify) g_hash_table_destroy);
  69 }
  70
  71 static void
  72 gprof_options_finalize (GObject *obj)
  73 {
  74         GProfOptions *self;
  75
  76         self = (GProfOptions *) obj;
  77
  78         g_hash_table_destroy (self->priv->default_options);
  79         g_hash_table_destroy (self->priv->key_data_table);
  80         g_hash_table_destroy (self->priv->targets);
  81
  82         g_free (self->priv);
  83 }
  84
  85 static void
  86 gprof_options_class_init (GProfOptionsClass *klass)
  87 {
  88         GObjectClass *object_class;
  89
  90         object_class = (GObjectClass *) klass;
  91         object_class->finalize = gprof_options_finalize;
  92 }
  93
  94 /* Copy defaults into a new target specifc settings table */
  95 static void
  96 copy_default_key (gchar *key, gchar *value, GHashTable *new_settings)
  97 {
  98         g_hash_table_insert (new_settings, g_strdup (key), g_strdup (value));
  99 }
 100
 101 static void
 102 gprof_options_parse_tree (GProfOptions *self, xmlNodePtr node)
 103 {
 104         xmlNodePtr current_node;
 105         xmlChar *target_name;
 106         xmlChar *key_name;
 107         xmlChar *key_value;
 108
 109         current_node = node;
 110
 111         while (current_node)
 112         {
 113                 if (strcmp ((gchar *) current_node->name, "target") == 0)
 114                 {
 115                         target_name = xmlGetProp (current_node, BAD_CAST "name");
 116                         gprof_options_set_target (self, (gchar *) target_name);
 117
 118                         xmlFree (target_name);
 119                 }
 120                 else if (strcmp ((gchar *) current_node->name, "key") == 0)
 121                 {
 122                         key_name = xmlGetProp (current_node, BAD_CAST "name");
 123                         key_value = xmlNodeGetContent (current_node);
 124
 125                         /* Filter out deprecated keys (those that aren't registered) */
 126                         if (g_hash_table_lookup_extended (self->priv->key_data_table,
 127                                                                                           (gchar *) key_name,
 128                                                                                           NULL, NULL))
 129                         {
 130                                 gprof_options_set_string (self, (gchar *) key_name,
 131                                                                                   (gchar *) key_value);
 132                         }
 133
 134                         xmlFree (key_name);
 135                         xmlFree (key_value);
 136                 }
 137
 138                 gprof_options_parse_tree (self, current_node->children);
 139                 current_node = current_node->next;
 140
 141         }
 142 }
 143
 144 static void
 145 build_key_elements (gchar *key, gchar *value, xmlNodePtr parent)
 146 {
 147         xmlNodePtr new_key;
 148
 149         new_key = xmlNewChild (parent, NULL, BAD_CAST "key", BAD_CAST value);
 150         xmlNewProp (new_key, BAD_CAST "name", BAD_CAST key);
 151 }
 152
 153 static void
 154 build_target_elements (gchar *key, GHashTable *target_settings,
 155                                            xmlNodePtr parent)
 156 {
 157         xmlNodePtr new_target;
 158
 159         new_target = xmlNewChild (parent, NULL, BAD_CAST "target", NULL);
 160         xmlNewProp (new_target, BAD_CAST "name", BAD_CAST key);
 161
 162         g_hash_table_foreach (target_settings, (GHFunc) build_key_elements, new_target);
 163 }
 164
 165 /* GUI functions: callbacks and various setup functions */
 166 static void
 167 on_option_toggled (GtkToggleButton *button, Key *key)
 168 {
 169         if (gtk_toggle_button_get_active (button))
 170                 gprof_options_set_int (key->options, key->name, 1);
 171         else
 172                 gprof_options_set_int (key->options, key->name, 0);
 173 }
 174
 175 static gboolean
 176 on_option_focus_out (GtkWidget *text_view, GdkEventFocus *event,
 177                                          Key *key)
 178 {
 179         GtkTextBuffer *text_buffer;
 180         GtkTextIter start_iter;
 181         GtkTextIter end_iter;
 182         gchar *string;
 183
 184         text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
 185         gtk_text_buffer_get_start_iter (text_buffer, &start_iter);
 186         gtk_text_buffer_get_end_iter (text_buffer, &end_iter);
 187         string = gtk_text_buffer_get_text (text_buffer, &start_iter, &end_iter, FALSE);
 188
 189         gprof_options_set_string (key->options, key->name, string);
 190
 191         g_free (string);
 192
 193         return FALSE;
 194 }
 195
 196 static void
 197 on_option_changed (GtkEditable *editable, Key *key)
 198 {
 199         gchar *string;
 200
 201         string = gtk_editable_get_chars (editable, 0, -1);
 202         gprof_options_set_string (key->options, key->name, string);
 203
 204         g_free (string);
 205 }
 206
 207 static void
 208 setup_widgets (gchar *key_name, Key *key, GtkBuilder *bxml)
 209 {
 210         GtkWidget *widget;
 211         GtkTextBuffer *buffer;
 212         gchar *string;
 213
 214         widget = GTK_WIDGET (gtk_builder_get_object (bxml, key->widget_name));
 215
 216         if (widget)
 217         {
 218                 switch (key->widget_type)
 219                 {
 220                         case OPTION_TYPE_TOGGLE:
 221                                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
 222                                                                                           gprof_options_get_int (key->options,
 223                                                                                                                                          key_name));
 224                                 g_signal_connect (widget, "toggled", G_CALLBACK (on_option_toggled),
 225                                                                   key);
 226                                 break;
 227                         case OPTION_TYPE_TEXT_ENTRY:
 228                                 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));
 229                                 string = gprof_options_get_string (key->options, key_name);
 230                                 gtk_text_buffer_set_text (buffer, string, -1);
 231
 232                                 g_signal_connect (widget, "focus-out-event", G_CALLBACK (on_option_focus_out),
 233                                                                   key);
 234
 235                                 g_free (string);
 236                                 break;
 237                         case OPTION_TYPE_ENTRY:
 238                                 string = gprof_options_get_string (key->options, key->name);
 239                                 gtk_entry_set_text (GTK_ENTRY (widget), string);
 240
 241                                 g_signal_connect (widget, "changed", G_CALLBACK (on_option_changed),
 242                                                                   key);
 243
 244                                 g_free (string);
 245                                 break;
 246                         default:
 247                                 break;
 248                 }
 249         }
 250 }
 251
 252 GType
 253 gprof_options_get_type (void)
 254 {
 255         static GType obj_type = 0;
 256
 257         if (!obj_type)
 258         {
 259                 static const GTypeInfo obj_info =
 260                 {
 261                         sizeof (GProfOptionsClass),
 262                         (GBaseInitFunc) NULL,
 263                         (GBaseFinalizeFunc) NULL,
 264                         (GClassInitFunc) gprof_options_class_init,
 265                         (GClassFinalizeFunc) NULL,
 266                         NULL,           /* class_data */
 267                         sizeof (GProfOptions),
 268                         0,              /* n_preallocs */
 269                         (GInstanceInitFunc) gprof_options_init,
 270                         NULL            /* value_table */
 271                 };
 272                 obj_type = g_type_register_static (G_TYPE_OBJECT,
 273                                                    "GProfOptions", &obj_info, 0);
 274         }
 275         return obj_type;
 276 }
 277
 278 GProfOptions *
 279 gprof_options_new ()
 280 {
 281         return g_object_new (GPROF_OPTIONS_TYPE, NULL);
 282 }
 283
 284 void
 285 gprof_options_destroy (GProfOptions *self)
 286 {
 287         g_object_unref (self);
 288 }
 289
 290 void
 291 gprof_options_set_target (GProfOptions *self, gchar *target)
 292 {
 293         GHashTable *new_table;
 294
 295         if (target)
 296         {
 297                 /* First, the target must have an entry in the target table. If we don't
 298                  * have one, set one up and copy the defaults into it. */
 299
 300                 if (!g_hash_table_lookup_extended (self->priv->targets, target,
 301                                                                                    NULL, NULL))
 302                 {
 303                         new_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
 304                                                                                            g_free);
 305                         g_hash_table_foreach (self->priv->default_options,
 306                                                                   (GHFunc) copy_default_key, new_table);
 307                         g_hash_table_insert (self->priv->targets, g_strdup (target),
 308                                                                  new_table);
 309                 }
 310
 311                 self->priv->current_target = g_hash_table_lookup (self->priv->targets,
 312                                                                                                                   target);
 313         }
 314         else
 315                 self->priv->current_target = NULL;
 316 }
 317
 318 gboolean
 319 gprof_options_has_target (GProfOptions *self, gchar *target)
 320 {
 321         return g_hash_table_lookup_extended (self->priv->targets, target,
 322                                                                                  NULL, NULL);
 323 }
 324
 325 /* Free returned string */
 326 gchar *
 327 gprof_options_get_string (GProfOptions *self, const gchar *key)
 328 {
 329         if (self->priv->current_target)
 330         {
 331                 return g_strdup (g_hash_table_lookup (self->priv->current_target,
 332                                                                                           key));
 333         }
 334         else
 335         {
 336                 return g_strdup (g_hash_table_lookup (self->priv->default_options,
 337                                                                                           key));
 338         }
 339
 340         return NULL;
 341 }
 342
 343 gint
 344 gprof_options_get_int (GProfOptions *self, const gchar *key)
 345 {
 346         gchar *value_string;
 347         gint value;
 348
 349         value_string = gprof_options_get_string (self, key);
 350
 351         if (value_string)
 352         {
 353                 value = atoi (value_string);
 354                 g_free (value_string);
 355         }
 356         else
 357                 value = 0;
 358
 359         return value;
 360 }
 361
 362 void
 363 gprof_options_set_string (GProfOptions *self, gchar *key, gchar *value)
 364 {
 365         if (self->priv->current_target)
 366         {
 367                 g_hash_table_insert (self->priv->current_target,
 368                                                          g_strdup (key), g_strdup (value));
 369         }
 370         else
 371         {
 372                 g_warning ("GProfOptions: Trying to set option value with "
 373                                    "no target.\n");
 374         }
 375 }
 376
 377 void
 378 gprof_options_set_int (GProfOptions *self, gchar *key, gint value)
 379 {
 380         gchar *value_string;
 381
 382         value_string = g_strdup_printf ("%i", value);
 383         gprof_options_set_string (self, key, value_string);
 384
 385         g_free (value_string);
 386 }
 387
 388 void
 389 gprof_options_register_key (GProfOptions *self, gchar *key_name,
 390                                                         const gchar *default_value,
 391                                                         const gchar *widget_name,
 392                                                         OptionWidgetType widget_type)
 393 {
 394         Key *new_key;
 395
 396         new_key = g_new0 (Key, 1);
 397
 398         new_key->name = g_strdup (key_name);
 399         new_key->widget_name = g_strdup (widget_name);
 400         new_key->options = self;
 401         new_key->widget_type = widget_type;
 402
 403         g_hash_table_insert (self->priv->key_data_table, g_strdup (key_name),
 404                                                  new_key);
 405         g_hash_table_insert (self->priv->default_options, g_strdup (key_name),
 406                                                  g_strdup (default_value));
 407 }
 408
 409 void
 410 gprof_options_create_window (GProfOptions *self, GtkBuilder *bxml)
 411 {
 412         g_hash_table_foreach (self->priv->key_data_table, (GHFunc) setup_widgets,
 413                                                   bxml);
 414 }
 415
 416 void
 417 gprof_options_load (GProfOptions *self, const gchar *path)
 418 {
 419         if (g_file_test (path, G_FILE_TEST_EXISTS))
 420         {
 421                 xmlDocPtr settings_doc;
 422                 xmlNodePtr root;
 423
 424                 settings_doc = xmlReadFile (path, NULL, 0);
 425                 root = xmlDocGetRootElement (settings_doc);
 426
 427                 gprof_options_parse_tree (self, root);
 428
 429                 xmlFreeDoc (settings_doc);
 430                 xmlCleanupParser ();
 431         }
 432 }
 433
 434 void
 435 gprof_options_save (GProfOptions *self, const gchar *path)
 436 {
 437         xmlDocPtr settings_doc;
 438         xmlNodePtr root_node;
 439
 440         settings_doc = xmlNewDoc (BAD_CAST "1.0");
 441         root_node = xmlNewNode (NULL, BAD_CAST "profiler-settings");
 442         xmlDocSetRootElement (settings_doc, root_node);
 443
 444         g_hash_table_foreach (self->priv->targets, (GHFunc) build_target_elements,
 445                                                   root_node);
 446
 447         xmlSaveFormatFile (path, settings_doc, TRUE);
 448
 449         xmlFreeDoc (settings_doc);
 450         xmlCleanupParser ();
 451 }