Pileus Git - ~andy/gtk/blob - tests/prop-editor.c

   1 /* prop-editor.c
   2  * Copyright (C) 2000  Red Hat, Inc.
   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 Library 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 #include <config.h>
  21 #include <string.h>
  22
  23 #undef GTK_DISABLE_DEPRECATED
  24 #include <gtk/gtk.h>
  25
  26 #include "prop-editor.h"
  27
  28
  29 typedef struct
  30 {
  31   gpointer instance;
  32   GObject *alive_object;
  33   guint id;
  34 } DisconnectData;
  35
  36 static void
  37 disconnect_func (gpointer data)
  38 {
  39   DisconnectData *dd = data;
  40
  41   g_signal_handler_disconnect (dd->instance, dd->id);
  42 }
  43
  44 static void
  45 signal_removed (gpointer  data,
  46                 GClosure *closure)
  47 {
  48   DisconnectData *dd = data;
  49
  50   g_object_steal_data (dd->alive_object, "alive-object-data");
  51   g_free (dd);
  52 }
  53
  54 static gboolean
  55 is_child_property (GParamSpec *pspec)
  56 {
  57   return g_param_spec_get_qdata (pspec, g_quark_from_string ("is-child-prop")) != NULL;
  58 }
  59
  60 static void
  61 mark_child_property (GParamSpec *pspec)
  62 {
  63   g_param_spec_set_qdata (pspec, g_quark_from_string ("is-child-prop"),
  64                           GINT_TO_POINTER (TRUE));
  65 }
  66
  67 static void
  68 g_object_connect_property (GObject     *object,
  69                            GParamSpec  *spec,
  70                            GCallback    func,
  71                            gpointer     data,
  72                            GObject     *alive_object)
  73 {
  74   GClosure *closure;
  75   gchar *with_detail;
  76   DisconnectData *dd;
  77
  78   if (is_child_property (spec))
  79     with_detail = g_strconcat ("child-notify::", spec->name, NULL);
  80   else
  81     with_detail = g_strconcat ("notify::", spec->name, NULL);
  82
  83   dd = g_new (DisconnectData, 1);
  84
  85   closure = g_cclosure_new (func, data, NULL);
  86
  87   g_closure_add_invalidate_notifier (closure, dd, signal_removed);
  88
  89   dd->id = g_signal_connect_closure (object, with_detail,
  90                                      closure, FALSE);
  91
  92   dd->instance = object;
  93   dd->alive_object = alive_object;
  94
  95   g_object_set_data_full (G_OBJECT (alive_object),
  96                           "alive-object-data",
  97                           dd,
  98                           disconnect_func);
  99
 100   g_free (with_detail);
 101 }
 102
 103 typedef struct
 104 {
 105   GObject *obj;
 106   GParamSpec *spec;
 107   gint modified_id;
 108 } ObjectProperty;
 109
 110 static void
 111 free_object_property (ObjectProperty *p)
 112 {
 113   g_free (p);
 114 }
 115
 116 static void
 117 connect_controller (GObject       *controller,
 118                     const gchar   *signal,
 119                     GObject       *model,
 120                     GParamSpec    *spec,
 121                     GtkSignalFunc  func)
 122 {
 123   ObjectProperty *p;
 124
 125   p = g_new (ObjectProperty, 1);
 126   p->obj = model;
 127   p->spec = spec;
 128
 129   p->modified_id = g_signal_connect_data (controller, signal, func, p,
 130                                           (GClosureNotify)free_object_property,
 131                                           0);
 132   g_object_set_data (controller, "object-property", p);
 133 }
 134
 135 static void
 136 block_controller (GObject *controller)
 137 {
 138   ObjectProperty *p = g_object_get_data (controller, "object-property");
 139
 140   if (p)
 141     g_signal_handler_block (controller, p->modified_id);
 142 }
 143
 144 static void
 145 unblock_controller (GObject *controller)
 146 {
 147   ObjectProperty *p = g_object_get_data (controller, "object-property");
 148
 149   if (p)
 150     g_signal_handler_unblock (controller, p->modified_id);
 151 }
 152
 153 static void
 154 int_modified (GtkAdjustment *adj, gpointer data)
 155 {
 156   ObjectProperty *p = data;
 157
 158   if (is_child_property (p->spec))
 159     {
 160       GtkWidget *widget = GTK_WIDGET (p->obj);
 161       GtkWidget *parent = gtk_widget_get_parent (widget);
 162
 163       gtk_container_child_set (GTK_CONTAINER (parent),
 164                                widget, p->spec->name, (int) adj->value, NULL);
 165     }
 166   else
 167     g_object_set (p->obj, p->spec->name, (int) adj->value, NULL);
 168 }
 169
 170 static void
 171 get_property_value (GObject *object, GParamSpec *pspec, GValue *value)
 172 {
 173   if (is_child_property (pspec))
 174     {
 175       GtkWidget *widget = GTK_WIDGET (object);
 176       GtkWidget *parent = gtk_widget_get_parent (widget);
 177
 178       gtk_container_child_get_property (GTK_CONTAINER (parent),
 179                                         widget, pspec->name, value);
 180     }
 181   else
 182     g_object_get_property (object, pspec->name, value);
 183 }
 184
 185 static void
 186 int_changed (GObject *object, GParamSpec *pspec, gpointer data)
 187 {
 188   GtkAdjustment *adj = GTK_ADJUSTMENT (data);
 189   GValue val = { 0, };
 190
 191   g_value_init (&val, G_TYPE_INT);
 192
 193   get_property_value (object, pspec, &val);
 194
 195   if (g_value_get_int (&val) != (int)adj->value)
 196     {
 197       block_controller (G_OBJECT (adj));
 198       gtk_adjustment_set_value (adj, g_value_get_int (&val));
 199       unblock_controller (G_OBJECT (adj));
 200     }
 201
 202   g_value_unset (&val);
 203 }
 204
 205 static void
 206 uint_modified (GtkAdjustment *adj, gpointer data)
 207 {
 208   ObjectProperty *p = data;
 209
 210   if (is_child_property (p->spec))
 211     {
 212       GtkWidget *widget = GTK_WIDGET (p->obj);
 213       GtkWidget *parent = gtk_widget_get_parent (widget);
 214
 215       gtk_container_child_set (GTK_CONTAINER (parent),
 216                                widget, p->spec->name, (guint) adj->value, NULL);
 217     }
 218   else
 219     g_object_set (p->obj, p->spec->name, (guint) adj->value, NULL);
 220 }
 221
 222 static void
 223 uint_changed (GObject *object, GParamSpec *pspec, gpointer data)
 224 {
 225   GtkAdjustment *adj = GTK_ADJUSTMENT (data);
 226   GValue val = { 0, };
 227
 228   g_value_init (&val, G_TYPE_UINT);
 229   get_property_value (object, pspec, &val);
 230
 231   if (g_value_get_uint (&val) != (guint)adj->value)
 232     {
 233       block_controller (G_OBJECT (adj));
 234       gtk_adjustment_set_value (adj, g_value_get_uint (&val));
 235       unblock_controller (G_OBJECT (adj));
 236     }
 237
 238   g_value_unset (&val);
 239 }
 240
 241 static void
 242 float_modified (GtkAdjustment *adj, gpointer data)
 243 {
 244   ObjectProperty *p = data;
 245
 246   if (is_child_property (p->spec))
 247     {
 248       GtkWidget *widget = GTK_WIDGET (p->obj);
 249       GtkWidget *parent = gtk_widget_get_parent (widget);
 250
 251       gtk_container_child_set (GTK_CONTAINER (parent),
 252                                widget, p->spec->name, (float) adj->value, NULL);
 253     }
 254   else
 255     g_object_set (p->obj, p->spec->name, (float) adj->value, NULL);
 256 }
 257
 258 static void
 259 float_changed (GObject *object, GParamSpec *pspec, gpointer data)
 260 {
 261   GtkAdjustment *adj = GTK_ADJUSTMENT (data);
 262   GValue val = { 0, };
 263
 264   g_value_init (&val, G_TYPE_FLOAT);
 265   get_property_value (object, pspec, &val);
 266
 267   if (g_value_get_float (&val) != (float) adj->value)
 268     {
 269       block_controller (G_OBJECT (adj));
 270       gtk_adjustment_set_value (adj, g_value_get_float (&val));
 271       unblock_controller (G_OBJECT (adj));
 272     }
 273
 274   g_value_unset (&val);
 275 }
 276
 277 static void
 278 double_modified (GtkAdjustment *adj, gpointer data)
 279 {
 280   ObjectProperty *p = data;
 281
 282   if (is_child_property (p->spec))
 283     {
 284       GtkWidget *widget = GTK_WIDGET (p->obj);
 285       GtkWidget *parent = gtk_widget_get_parent (widget);
 286
 287       gtk_container_child_set (GTK_CONTAINER (parent),
 288                                widget, p->spec->name, (double) adj->value, NULL);
 289     }
 290   else
 291     g_object_set (p->obj, p->spec->name, (double) adj->value, NULL);
 292 }
 293
 294 static void
 295 double_changed (GObject *object, GParamSpec *pspec, gpointer data)
 296 {
 297   GtkAdjustment *adj = GTK_ADJUSTMENT (data);
 298   GValue val = { 0, };
 299
 300   g_value_init (&val, G_TYPE_DOUBLE);
 301   get_property_value (object, pspec, &val);
 302
 303   if (g_value_get_double (&val) != adj->value)
 304     {
 305       block_controller (G_OBJECT (adj));
 306       gtk_adjustment_set_value (adj, g_value_get_double (&val));
 307       unblock_controller (G_OBJECT (adj));
 308     }
 309
 310   g_value_unset (&val);
 311 }
 312
 313 static void
 314 string_modified (GtkEntry *entry, gpointer data)
 315 {
 316   ObjectProperty *p = data;
 317   const gchar *text;
 318
 319   text = gtk_entry_get_text (entry);
 320
 321   if (is_child_property (p->spec))
 322     {
 323       GtkWidget *widget = GTK_WIDGET (p->obj);
 324       GtkWidget *parent = gtk_widget_get_parent (widget);
 325
 326       gtk_container_child_set (GTK_CONTAINER (parent),
 327                                widget, p->spec->name, text, NULL);
 328     }
 329   else
 330     g_object_set (p->obj, p->spec->name, text, NULL);
 331 }
 332
 333 static void
 334 string_changed (GObject *object, GParamSpec *pspec, gpointer data)
 335 {
 336   GtkEntry *entry = GTK_ENTRY (data);
 337   GValue val = { 0, };
 338   const gchar *str;
 339   const gchar *text;
 340
 341   g_value_init (&val, G_TYPE_STRING);
 342   get_property_value (object, pspec, &val);
 343
 344   str = g_value_get_string (&val);
 345   if (str == NULL)
 346     str = "";
 347   text = gtk_entry_get_text (entry);
 348
 349   if (strcmp (str, text) != 0)
 350     {
 351       block_controller (G_OBJECT (entry));
 352       gtk_entry_set_text (entry, str);
 353       unblock_controller (G_OBJECT (entry));
 354     }
 355
 356   g_value_unset (&val);
 357 }
 358
 359 static void
 360 bool_modified (GtkToggleButton *tb, gpointer data)
 361 {
 362   ObjectProperty *p = data;
 363
 364   if (is_child_property (p->spec))
 365     {
 366       GtkWidget *widget = GTK_WIDGET (p->obj);
 367       GtkWidget *parent = gtk_widget_get_parent (widget);
 368
 369       gtk_container_child_set (GTK_CONTAINER (parent),
 370                                widget, p->spec->name, (int) tb->active, NULL);
 371     }
 372   else
 373     g_object_set (p->obj, p->spec->name, (int) tb->active, NULL);
 374 }
 375
 376 static void
 377 bool_changed (GObject *object, GParamSpec *pspec, gpointer data)
 378 {
 379   GtkToggleButton *tb = GTK_TOGGLE_BUTTON (data);
 380   GValue val = { 0, };
 381
 382   g_value_init (&val, G_TYPE_BOOLEAN);
 383   get_property_value (object, pspec, &val);
 384
 385   if (g_value_get_boolean (&val) != tb->active)
 386     {
 387       block_controller (G_OBJECT (tb));
 388       gtk_toggle_button_set_active (tb, g_value_get_boolean (&val));
 389       unblock_controller (G_OBJECT (tb));
 390     }
 391
 392   gtk_label_set_text (GTK_LABEL (GTK_BIN (tb)->child), g_value_get_boolean (&val) ?
 393                       "TRUE" : "FALSE");
 394
 395   g_value_unset (&val);
 396 }
 397
 398
 399 static void
 400 enum_modified (GtkOptionMenu *om, gpointer data)
 401 {
 402   ObjectProperty *p = data;
 403   gint i;
 404   GEnumClass *eclass;
 405
 406   eclass = G_ENUM_CLASS (g_type_class_peek (p->spec->value_type));
 407
 408   i = gtk_option_menu_get_history (om);
 409
 410   if (is_child_property (p->spec))
 411     {
 412       GtkWidget *widget = GTK_WIDGET (p->obj);
 413       GtkWidget *parent = gtk_widget_get_parent (widget);
 414
 415       gtk_container_child_set (GTK_CONTAINER (parent),
 416                                widget, p->spec->name, eclass->values[i].value, NULL);
 417     }
 418   else
 419     g_object_set (p->obj, p->spec->name, eclass->values[i].value, NULL);
 420 }
 421
 422 static void
 423 enum_changed (GObject *object, GParamSpec *pspec, gpointer data)
 424 {
 425   GtkOptionMenu *om = GTK_OPTION_MENU (data);
 426   GValue val = { 0, };
 427   GEnumClass *eclass;
 428   gint i;
 429
 430   eclass = G_ENUM_CLASS (g_type_class_peek (pspec->value_type));
 431
 432   g_value_init (&val, pspec->value_type);
 433   get_property_value (object, pspec, &val);
 434
 435   i = 0;
 436   while (i < eclass->n_values)
 437     {
 438       if (eclass->values[i].value == g_value_get_enum (&val))
 439         break;
 440       ++i;
 441     }
 442
 443   if (gtk_option_menu_get_history (om) != i)
 444     {
 445       block_controller (G_OBJECT (om));
 446       gtk_option_menu_set_history (om, i);
 447       unblock_controller (G_OBJECT (om));
 448     }
 449
 450   g_value_unset (&val);
 451
 452 }
 453
 454 static gunichar
 455 unichar_get_value (GtkEntry *entry)
 456 {
 457   const gchar *text = gtk_entry_get_text (entry);
 458
 459   if (text[0])
 460     return g_utf8_get_char (text);
 461   else
 462     return 0;
 463 }
 464
 465 static void
 466 unichar_modified (GtkEntry *entry, gpointer data)
 467 {
 468   ObjectProperty *p = data;
 469   gunichar val = unichar_get_value (entry);
 470
 471   if (is_child_property (p->spec))
 472     {
 473       GtkWidget *widget = GTK_WIDGET (p->obj);
 474       GtkWidget *parent = gtk_widget_get_parent (widget);
 475
 476       gtk_container_child_set (GTK_CONTAINER (parent),
 477                                widget, p->spec->name, val, NULL);
 478     }
 479   else
 480     g_object_set (p->obj, p->spec->name, val, NULL);
 481 }
 482
 483 static void
 484 unichar_changed (GObject *object, GParamSpec *pspec, gpointer data)
 485 {
 486   GtkEntry *entry = GTK_ENTRY (data);
 487   gunichar new_val;
 488   gunichar old_val = unichar_get_value (entry);
 489   GValue val;
 490   gchar buf[7];
 491   gint len;
 492
 493   g_value_init (&val, pspec->value_type);
 494   get_property_value (object, pspec, &val);
 495   new_val = (gunichar)g_value_get_uint (&val);
 496
 497   if (new_val != old_val)
 498     {
 499       if (!new_val)
 500         len = 0;
 501       else
 502         len = g_unichar_to_utf8 (new_val, buf);
 503
 504       buf[len] = '\0';
 505
 506       block_controller (G_OBJECT (entry));
 507       gtk_entry_set_text (entry, buf);
 508       unblock_controller (G_OBJECT (entry));
 509     }
 510 }
 511
 512 static void
 513 pointer_changed (GObject *object, GParamSpec *pspec, gpointer data)
 514 {
 515   GtkLabel *label = GTK_LABEL (data);
 516   gchar *str;
 517   gpointer ptr;
 518
 519   g_object_get (object, pspec->name, &ptr, NULL);
 520
 521   str = g_strdup_printf ("Pointer: %p", ptr);
 522   gtk_label_set_text (label, str);
 523   g_free (str);
 524 }
 525
 526 static void
 527 object_changed (GObject *object, GParamSpec *pspec, gpointer data)
 528 {
 529   GtkWidget *label, *button;
 530   gchar *str;
 531   GObject *obj;
 532   const gchar *name;
 533
 534   GList *children = gtk_container_get_children (GTK_CONTAINER (data));
 535   label = GTK_WIDGET (children->data);
 536   button = GTK_WIDGET (children->next->data);
 537   g_object_get (object, pspec->name, &obj, NULL);
 538   g_list_free (children);
 539
 540   if (obj)
 541     name = g_type_name (G_TYPE_FROM_INSTANCE (obj));
 542   else
 543     name = "unknown";
 544   str = g_strdup_printf ("Object: %p (%s)", obj, name);
 545
 546   gtk_label_set_text (GTK_LABEL (label), str);
 547   gtk_widget_set_sensitive (button, G_IS_OBJECT (obj));
 548
 549   if (obj)
 550     g_object_unref (obj);
 551
 552   g_free (str);
 553 }
 554
 555 static void
 556 model_destroy (gpointer data)
 557 {
 558   g_object_steal_data (data, "model-object");
 559   gtk_widget_destroy (data);
 560 }
 561
 562 static void
 563 window_destroy (gpointer data)
 564 {
 565   g_object_steal_data (data, "prop-editor-win");
 566 }
 567
 568 static void
 569 object_properties (GtkWidget *button,
 570                    GObject   *object)
 571 {
 572   gchar *name;
 573   GObject *obj;
 574
 575   name = (gchar *) g_object_get_data (G_OBJECT (button), "property-name");
 576   g_object_get (object, name, &obj, NULL);
 577   if (G_IS_OBJECT (obj))
 578     create_prop_editor (obj, 0);
 579 }
 580
 581 static GtkWidget *
 582 property_widget (GObject    *object,
 583                  GParamSpec *spec,
 584                  gboolean    can_modify)
 585 {
 586   GtkWidget *prop_edit;
 587   GtkAdjustment *adj;
 588   gchar *msg;
 589   GType type = G_PARAM_SPEC_TYPE (spec);
 590
 591   if (type == G_TYPE_PARAM_INT)
 592     {
 593       adj = GTK_ADJUSTMENT (gtk_adjustment_new (G_PARAM_SPEC_INT (spec)->default_value,
 594                                                 G_PARAM_SPEC_INT (spec)->minimum,
 595                                                 G_PARAM_SPEC_INT (spec)->maximum,
 596                                                 1,
 597                                                 MAX ((G_PARAM_SPEC_INT (spec)->maximum -
 598                                                       G_PARAM_SPEC_INT (spec)->minimum) / 10, 1),
 599                                                 0.0));
 600
 601       prop_edit = gtk_spin_button_new (adj, 1.0, 0);
 602
 603       g_object_connect_property (object, spec,
 604                                  G_CALLBACK (int_changed),
 605                                  adj, G_OBJECT (adj));
 606
 607       if (can_modify)
 608         connect_controller (G_OBJECT (adj), "value_changed",
 609                             object, spec, (GtkSignalFunc) int_modified);
 610     }
 611   else if (type == G_TYPE_PARAM_UINT)
 612     {
 613       adj = GTK_ADJUSTMENT (
 614                             gtk_adjustment_new (G_PARAM_SPEC_UINT (spec)->default_value,
 615                                                 G_PARAM_SPEC_UINT (spec)->minimum,
 616                                                 G_PARAM_SPEC_UINT (spec)->maximum,
 617                                                 1,
 618                                                 MAX ((G_PARAM_SPEC_UINT (spec)->maximum -
 619                                                       G_PARAM_SPEC_UINT (spec)->minimum) / 10, 1),
 620                                                 0.0));
 621
 622       prop_edit = gtk_spin_button_new (adj, 1.0, 0);
 623
 624       g_object_connect_property (object, spec,
 625                                  G_CALLBACK (uint_changed),
 626                                  adj, G_OBJECT (adj));
 627
 628       if (can_modify)
 629         connect_controller (G_OBJECT (adj), "value_changed",
 630                             object, spec, (GtkSignalFunc) uint_modified);
 631     }
 632   else if (type == G_TYPE_PARAM_FLOAT)
 633     {
 634
 635       adj = GTK_ADJUSTMENT (gtk_adjustment_new (G_PARAM_SPEC_FLOAT (spec)->default_value,
 636                                                 G_PARAM_SPEC_FLOAT (spec)->minimum,
 637                                                 G_PARAM_SPEC_FLOAT (spec)->maximum,
 638                                                 0.1,
 639                                                 MAX ((G_PARAM_SPEC_FLOAT (spec)->maximum -
 640                                                       G_PARAM_SPEC_FLOAT (spec)->minimum) / 10, 0.1),
 641                                                 0.0));
 642
 643       prop_edit = gtk_spin_button_new (adj, 0.1, 2);
 644
 645       g_object_connect_property (object, spec,
 646                                  G_CALLBACK (float_changed),
 647                                  adj, G_OBJECT (adj));
 648
 649       if (can_modify)
 650         connect_controller (G_OBJECT (adj), "value_changed",
 651                             object, spec, (GtkSignalFunc) float_modified);
 652     }
 653   else if (type == G_TYPE_PARAM_DOUBLE)
 654     {
 655       adj = GTK_ADJUSTMENT (gtk_adjustment_new (G_PARAM_SPEC_DOUBLE (spec)->default_value,
 656                                                 G_PARAM_SPEC_DOUBLE (spec)->minimum,
 657                                                 G_PARAM_SPEC_DOUBLE (spec)->maximum,
 658                                                 0.1,
 659                                                 MAX ((G_PARAM_SPEC_DOUBLE (spec)->maximum -
 660                                                       G_PARAM_SPEC_DOUBLE (spec)->minimum) / 10, 0.1),
 661                                                 0.0));
 662
 663       prop_edit = gtk_spin_button_new (adj, 0.1, 2);
 664
 665       g_object_connect_property (object, spec,
 666                                  G_CALLBACK (double_changed),
 667                                  adj, G_OBJECT (adj));
 668
 669       if (can_modify)
 670         connect_controller (G_OBJECT (adj), "value_changed",
 671                             object, spec, (GtkSignalFunc) double_modified);
 672     }
 673   else if (type == G_TYPE_PARAM_STRING)
 674     {
 675       prop_edit = gtk_entry_new ();
 676
 677       g_object_connect_property (object, spec,
 678                                  G_CALLBACK (string_changed),
 679                                  prop_edit, G_OBJECT (prop_edit));
 680
 681       if (can_modify)
 682         connect_controller (G_OBJECT (prop_edit), "changed",
 683                             object, spec, (GtkSignalFunc) string_modified);
 684     }
 685   else if (type == G_TYPE_PARAM_BOOLEAN)
 686     {
 687       prop_edit = gtk_toggle_button_new_with_label ("");
 688
 689       g_object_connect_property (object, spec,
 690                                  G_CALLBACK (bool_changed),
 691                                  prop_edit, G_OBJECT (prop_edit));
 692
 693       if (can_modify)
 694         connect_controller (G_OBJECT (prop_edit), "toggled",
 695                             object, spec, (GtkSignalFunc) bool_modified);
 696     }
 697   else if (type == G_TYPE_PARAM_ENUM)
 698     {
 699       {
 700         GtkWidget *menu;
 701         GEnumClass *eclass;
 702         gint j;
 703
 704         prop_edit = gtk_option_menu_new ();
 705
 706         menu = gtk_menu_new ();
 707
 708         eclass = G_ENUM_CLASS (g_type_class_ref (spec->value_type));
 709
 710         j = 0;
 711         while (j < eclass->n_values)
 712           {
 713             GtkWidget *mi;
 714
 715             mi = gtk_menu_item_new_with_label (eclass->values[j].value_name);
 716
 717             gtk_widget_show (mi);
 718
 719             gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
 720
 721             ++j;
 722           }
 723
 724         g_type_class_unref (eclass);
 725
 726         gtk_option_menu_set_menu (GTK_OPTION_MENU (prop_edit), menu);
 727
 728         g_object_connect_property (object, spec,
 729                                    G_CALLBACK (enum_changed),
 730                                    prop_edit, G_OBJECT (prop_edit));
 731
 732         if (can_modify)
 733           connect_controller (G_OBJECT (prop_edit), "changed",
 734                               object, spec, (GtkSignalFunc) enum_modified);
 735       }
 736     }
 737   else if (type == G_TYPE_PARAM_UNICHAR)
 738     {
 739       prop_edit = gtk_entry_new ();
 740       gtk_entry_set_max_length (GTK_ENTRY (prop_edit), 1);
 741
 742       g_object_connect_property (object, spec,
 743                                  G_CALLBACK (unichar_changed),
 744                                  prop_edit, G_OBJECT (prop_edit));
 745
 746       if (can_modify)
 747         connect_controller (G_OBJECT (prop_edit), "changed",
 748                             object, spec, (GtkSignalFunc) unichar_modified);
 749     }
 750   else if (type == G_TYPE_PARAM_POINTER)
 751     {
 752       prop_edit = gtk_label_new ("");
 753
 754       g_object_connect_property (object, spec,
 755                                  G_CALLBACK (pointer_changed),
 756                                  prop_edit, G_OBJECT (prop_edit));
 757     }
 758   else if (type == G_TYPE_PARAM_OBJECT)
 759     {
 760       GtkWidget *label, *button;
 761
 762       prop_edit = gtk_hbox_new (FALSE, 5);
 763
 764       label = gtk_label_new ("");
 765       button = gtk_button_new_with_label ("Properties");
 766       g_object_set_data (G_OBJECT (button), "property-name", spec->name);
 767       g_signal_connect (button, "clicked",
 768                         G_CALLBACK (object_properties),
 769                         object);
 770
 771       gtk_container_add (GTK_CONTAINER (prop_edit), label);
 772       gtk_container_add (GTK_CONTAINER (prop_edit), button);
 773
 774       g_object_connect_property (object, spec,
 775                                  G_CALLBACK (object_changed),
 776                                  prop_edit, G_OBJECT (label));
 777     }
 778   else
 779     {
 780       msg = g_strdup_printf ("uneditable property type: %s",
 781                              g_type_name (G_PARAM_SPEC_TYPE (spec)));
 782       prop_edit = gtk_label_new (msg);
 783       g_free (msg);
 784       gtk_misc_set_alignment (GTK_MISC (prop_edit), 0.0, 0.5);
 785     }
 786
 787   return prop_edit;
 788 }
 789
 790 static GtkWidget *
 791 properties_from_type (GObject     *object,
 792                       GType        type,
 793                       GtkTooltips *tips)
 794 {
 795   GtkWidget *prop_edit;
 796   GtkWidget *label;
 797   GtkWidget *sw;
 798   GtkWidget *vbox;
 799   GtkWidget *table;
 800   GParamSpec **specs;
 801   guint n_specs;
 802   int i;
 803
 804   if (G_TYPE_IS_INTERFACE (type))
 805     {
 806       gpointer vtable = g_type_default_interface_peek (type);
 807       specs = g_object_interface_list_properties (vtable, &n_specs);
 808     }
 809   else
 810     {
 811       GObjectClass *class = G_OBJECT_CLASS (g_type_class_peek (type));
 812       specs = g_object_class_list_properties (class, &n_specs);
 813     }
 814
 815   if (n_specs == 0)
 816     return NULL;
 817
 818   table = gtk_table_new (n_specs, 2, FALSE);
 819   gtk_table_set_col_spacing (GTK_TABLE (table), 0, 10);
 820   gtk_table_set_row_spacings (GTK_TABLE (table), 3);
 821
 822   i = 0;
 823   while (i < n_specs)
 824     {
 825       GParamSpec *spec = specs[i];
 826       gboolean can_modify;
 827
 828       prop_edit = NULL;
 829
 830       can_modify = ((spec->flags & G_PARAM_WRITABLE) != 0 &&
 831                     (spec->flags & G_PARAM_CONSTRUCT_ONLY) == 0);
 832
 833       if ((spec->flags & G_PARAM_READABLE) == 0)
 834         {
 835           /* can't display unreadable properties */
 836           ++i;
 837           continue;
 838         }
 839
 840       if (spec->owner_type != type)
 841         {
 842           /* we're only interested in params of type */
 843           ++i;
 844           continue;
 845         }
 846
 847       label = gtk_label_new (g_param_spec_get_nick (spec));
 848       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 849       gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, i, i + 1);
 850
 851       prop_edit = property_widget (object, spec, can_modify);
 852       gtk_table_attach_defaults (GTK_TABLE (table), prop_edit, 1, 2, i, i + 1);
 853
 854       if (prop_edit)
 855         {
 856           if (!can_modify)
 857             gtk_widget_set_sensitive (prop_edit, FALSE);
 858
 859           if (g_param_spec_get_blurb (spec))
 860             gtk_tooltips_set_tip (tips, prop_edit, g_param_spec_get_blurb (spec), NULL);
 861
 862           /* set initial value */
 863           g_object_notify (object, spec->name);
 864         }
 865
 866       ++i;
 867     }
 868
 869
 870   vbox = gtk_vbox_new (FALSE, 0);
 871   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
 872
 873   sw = gtk_scrolled_window_new (NULL, NULL);
 874   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 875                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 876
 877   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), vbox);
 878
 879   g_free (specs);
 880
 881   return sw;
 882 }
 883
 884 static GtkWidget *
 885 child_properties_from_object (GObject     *object,
 886                               GtkTooltips *tips)
 887 {
 888   GtkWidget *prop_edit;
 889   GtkWidget *label;
 890   GtkWidget *sw;
 891   GtkWidget *vbox;
 892   GtkWidget *table;
 893   GtkWidget *parent;
 894   GParamSpec **specs;
 895   guint n_specs;
 896   gint i;
 897
 898   if (!GTK_IS_WIDGET (object))
 899     return NULL;
 900
 901   parent = gtk_widget_get_parent (GTK_WIDGET (object));
 902
 903   if (!parent)
 904     return NULL;
 905
 906   specs = gtk_container_class_list_child_properties (G_OBJECT_GET_CLASS (parent), &n_specs);
 907
 908   table = gtk_table_new (n_specs, 2, FALSE);
 909   gtk_table_set_col_spacing (GTK_TABLE (table), 0, 10);
 910   gtk_table_set_row_spacings (GTK_TABLE (table), 3);
 911
 912   i = 0;
 913   while (i < n_specs)
 914     {
 915       GParamSpec *spec = specs[i];
 916       gboolean can_modify;
 917
 918       prop_edit = NULL;
 919
 920       can_modify = ((spec->flags & G_PARAM_WRITABLE) != 0 &&
 921                     (spec->flags & G_PARAM_CONSTRUCT_ONLY) == 0);
 922
 923       if ((spec->flags & G_PARAM_READABLE) == 0)
 924         {
 925           /* can't display unreadable properties */
 926           ++i;
 927           continue;
 928         }
 929
 930       label = gtk_label_new (g_param_spec_get_nick (spec));
 931       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 932       gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, i, i + 1);
 933
 934       mark_child_property (spec);
 935       prop_edit = property_widget (object, spec, can_modify);
 936       gtk_table_attach_defaults (GTK_TABLE (table), prop_edit, 1, 2, i, i + 1);
 937
 938       if (prop_edit)
 939         {
 940           if (!can_modify)
 941             gtk_widget_set_sensitive (prop_edit, FALSE);
 942
 943           if (g_param_spec_get_blurb (spec))
 944             gtk_tooltips_set_tip (tips, prop_edit, g_param_spec_get_blurb (spec), NULL);
 945
 946           /* set initial value */
 947           gtk_widget_child_notify (GTK_WIDGET (object), spec->name);
 948         }
 949
 950       ++i;
 951     }
 952
 953   vbox = gtk_vbox_new (FALSE, 0);
 954   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
 955
 956   sw = gtk_scrolled_window_new (NULL, NULL);
 957   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 958                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 959
 960   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), vbox);
 961
 962   g_free (specs);
 963
 964   return sw;
 965 }
 966
 967 static void
 968 kill_tips (GtkWindow *win, GtkObject *tips)
 969 {
 970   gtk_object_destroy (tips);
 971   g_object_unref (tips);
 972 }
 973
 974 /* Pass zero for type if you want all properties */
 975 GtkWidget*
 976 create_prop_editor (GObject   *object,
 977                     GType      type)
 978 {
 979   GtkWidget *win;
 980   GtkWidget *notebook;
 981   GtkTooltips *tips;
 982   GtkWidget *properties;
 983   GtkWidget *label;
 984   gchar *title;
 985   GType *ifaces;
 986   guint n_ifaces;
 987
 988   if ((win = g_object_get_data (G_OBJECT (object), "prop-editor-win")))
 989     {
 990       gtk_window_present (GTK_WINDOW (win));
 991       return win;
 992     }
 993
 994   win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 995   if (GTK_IS_WIDGET (object))
 996     gtk_window_set_screen (GTK_WINDOW (win),
 997                            gtk_widget_get_screen (GTK_WIDGET (object)));
 998
 999   tips = gtk_tooltips_new ();
1000   g_object_ref (tips);
1001   gtk_object_sink (GTK_OBJECT (tips));
1002
1003   /* Kill the tips when the widget goes away.  */
1004   g_signal_connect (win, "destroy", G_CALLBACK (kill_tips), tips);
1005
1006   /* hold a weak ref to the object we're editing */
1007   g_object_set_data_full (G_OBJECT (object), "prop-editor-win", win, model_destroy);
1008   g_object_set_data_full (G_OBJECT (win), "model-object", object, window_destroy);
1009
1010   if (type == 0)
1011     {
1012       notebook = gtk_notebook_new ();
1013       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_LEFT);
1014
1015       gtk_container_add (GTK_CONTAINER (win), notebook);
1016
1017       type = G_TYPE_FROM_INSTANCE (object);
1018
1019       title = g_strdup_printf ("Properties of %s widget", g_type_name (type));
1020       gtk_window_set_title (GTK_WINDOW (win), title);
1021       g_free (title);
1022
1023       while (type)
1024         {
1025           properties = properties_from_type (object, type, tips);
1026           if (properties)
1027             {
1028               label = gtk_label_new (g_type_name (type));
1029               gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
1030                                         properties, label);
1031             }
1032
1033           type = g_type_parent (type);
1034         }
1035
1036       ifaces = g_type_interfaces (G_TYPE_FROM_INSTANCE (object), &n_ifaces);
1037       while (n_ifaces--)
1038         {
1039           properties = properties_from_type (object, ifaces[n_ifaces], tips);
1040           if (properties)
1041             {
1042               label = gtk_label_new (g_type_name (ifaces[n_ifaces]));
1043               gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
1044                                         properties, label);
1045             }
1046         }
1047
1048       g_free (ifaces);
1049
1050       properties = child_properties_from_object (object, tips);
1051       if (properties)
1052         {
1053           label = gtk_label_new ("Child properties");
1054           gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
1055                                     properties, label);
1056         }
1057     }
1058   else
1059     {
1060       properties = properties_from_type (object, type, tips);
1061       gtk_container_add (GTK_CONTAINER (win), properties);
1062       title = g_strdup_printf ("Properties of %s", g_type_name (type));
1063       gtk_window_set_title (GTK_WINDOW (win), title);
1064       g_free (title);
1065     }
1066
1067   gtk_window_set_default_size (GTK_WINDOW (win), -1, 400);
1068
1069   gtk_widget_show_all (win);
1070
1071   return win;
1072 }
1073