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 <string.h>
  21
  22 #include <gtk/gtk.h>
  23
  24 #include "prop-editor.h"
  25
  26
  27 typedef struct
  28 {
  29   gpointer instance;
  30   GObject *alive_object;
  31   guint id;
  32 } DisconnectData;
  33
  34 static void
  35 disconnect_func (gpointer data)
  36 {
  37   DisconnectData *dd = data;
  38
  39   g_signal_handler_disconnect (dd->instance, dd->id);
  40 }
  41
  42 static void
  43 signal_removed (gpointer  data,
  44                 GClosure *closure)
  45 {
  46   DisconnectData *dd = data;
  47
  48   g_object_steal_data (dd->alive_object, "alive-object-data");
  49   g_free (dd);
  50 }
  51
  52 static gboolean
  53 is_child_property (GParamSpec *pspec)
  54 {
  55   return g_param_spec_get_qdata (pspec, g_quark_from_string ("is-child-prop")) != NULL;
  56 }
  57
  58 static void
  59 mark_child_property (GParamSpec *pspec)
  60 {
  61   g_param_spec_set_qdata (pspec, g_quark_from_string ("is-child-prop"),
  62                           GINT_TO_POINTER (TRUE));
  63 }
  64
  65 static void
  66 g_object_connect_property (GObject     *object,
  67                            GParamSpec  *spec,
  68                            GCallback    func,
  69                            gpointer     data,
  70                            GObject     *alive_object)
  71 {
  72   GClosure *closure;
  73   gchar *with_detail;
  74   DisconnectData *dd;
  75
  76   if (is_child_property (spec))
  77     with_detail = g_strconcat ("child-notify::", spec->name, NULL);
  78   else
  79     with_detail = g_strconcat ("notify::", spec->name, NULL);
  80
  81   dd = g_new (DisconnectData, 1);
  82
  83   closure = g_cclosure_new (func, data, NULL);
  84
  85   g_closure_add_invalidate_notifier (closure, dd, signal_removed);
  86
  87   dd->id = g_signal_connect_closure (object, with_detail,
  88                                      closure, FALSE);
  89
  90   dd->instance = object;
  91   dd->alive_object = alive_object;
  92
  93   g_object_set_data_full (G_OBJECT (alive_object),
  94                           "alive-object-data",
  95                           dd,
  96                           disconnect_func);
  97
  98   g_free (with_detail);
  99 }
 100
 101 typedef struct
 102 {
 103   GObject *obj;
 104   GParamSpec *spec;
 105   gint modified_id;
 106 } ObjectProperty;
 107
 108 static void
 109 free_object_property (ObjectProperty *p)
 110 {
 111   g_free (p);
 112 }
 113
 114 static void
 115 connect_controller (GObject     *controller,
 116                     const gchar *signal,
 117                     GObject     *model,
 118                     GParamSpec  *spec,
 119                     GCallback    func)
 120 {
 121   ObjectProperty *p;
 122
 123   p = g_new (ObjectProperty, 1);
 124   p->obj = model;
 125   p->spec = spec;
 126
 127   p->modified_id = g_signal_connect_data (controller, signal, func, p,
 128                                           (GClosureNotify)free_object_property,
 129                                           0);
 130   g_object_set_data (controller, "object-property", p);
 131 }
 132
 133 static void
 134 block_controller (GObject *controller)
 135 {
 136   ObjectProperty *p = g_object_get_data (controller, "object-property");
 137
 138   if (p)
 139     g_signal_handler_block (controller, p->modified_id);
 140 }
 141
 142 static void
 143 unblock_controller (GObject *controller)
 144 {
 145   ObjectProperty *p = g_object_get_data (controller, "object-property");
 146
 147   if (p)
 148     g_signal_handler_unblock (controller, p->modified_id);
 149 }
 150
 151 static void
 152 int_modified (GtkAdjustment *adj, gpointer data)
 153 {
 154   ObjectProperty *p = data;
 155
 156   if (is_child_property (p->spec))
 157     {
 158       GtkWidget *widget = GTK_WIDGET (p->obj);
 159       GtkWidget *parent = gtk_widget_get_parent (widget);
 160
 161       gtk_container_child_set (GTK_CONTAINER (parent),
 162                                widget, p->spec->name, (int) adj->value, NULL);
 163     }
 164   else
 165     g_object_set (p->obj, p->spec->name, (int) adj->value, NULL);
 166 }
 167
 168 static void
 169 get_property_value (GObject *object, GParamSpec *pspec, GValue *value)
 170 {
 171   if (is_child_property (pspec))
 172     {
 173       GtkWidget *widget = GTK_WIDGET (object);
 174       GtkWidget *parent = gtk_widget_get_parent (widget);
 175
 176       gtk_container_child_get_property (GTK_CONTAINER (parent),
 177                                         widget, pspec->name, value);
 178     }
 179   else
 180     g_object_get_property (object, pspec->name, value);
 181 }
 182
 183 static void
 184 int_changed (GObject *object, GParamSpec *pspec, gpointer data)
 185 {
 186   GtkAdjustment *adj = GTK_ADJUSTMENT (data);
 187   GValue val = { 0, };
 188
 189   g_value_init (&val, G_TYPE_INT);
 190
 191   get_property_value (object, pspec, &val);
 192
 193   if (g_value_get_int (&val) != (int)adj->value)
 194     {
 195       block_controller (G_OBJECT (adj));
 196       gtk_adjustment_set_value (adj, g_value_get_int (&val));
 197       unblock_controller (G_OBJECT (adj));
 198     }
 199
 200   g_value_unset (&val);
 201 }
 202
 203 static void
 204 uint_modified (GtkAdjustment *adj, gpointer data)
 205 {
 206   ObjectProperty *p = data;
 207
 208   if (is_child_property (p->spec))
 209     {
 210       GtkWidget *widget = GTK_WIDGET (p->obj);
 211       GtkWidget *parent = gtk_widget_get_parent (widget);
 212
 213       gtk_container_child_set (GTK_CONTAINER (parent),
 214                                widget, p->spec->name, (guint) adj->value, NULL);
 215     }
 216   else
 217     g_object_set (p->obj, p->spec->name, (guint) adj->value, NULL);
 218 }
 219
 220 static void
 221 uint_changed (GObject *object, GParamSpec *pspec, gpointer data)
 222 {
 223   GtkAdjustment *adj = GTK_ADJUSTMENT (data);
 224   GValue val = { 0, };
 225
 226   g_value_init (&val, G_TYPE_UINT);
 227   get_property_value (object, pspec, &val);
 228
 229   if (g_value_get_uint (&val) != (guint)adj->value)
 230     {
 231       block_controller (G_OBJECT (adj));
 232       gtk_adjustment_set_value (adj, g_value_get_uint (&val));
 233       unblock_controller (G_OBJECT (adj));
 234     }
 235
 236   g_value_unset (&val);
 237 }
 238
 239 static void
 240 float_modified (GtkAdjustment *adj, gpointer data)
 241 {
 242   ObjectProperty *p = data;
 243
 244   if (is_child_property (p->spec))
 245     {
 246       GtkWidget *widget = GTK_WIDGET (p->obj);
 247       GtkWidget *parent = gtk_widget_get_parent (widget);
 248
 249       gtk_container_child_set (GTK_CONTAINER (parent),
 250                                widget, p->spec->name, (float) adj->value, NULL);
 251     }
 252   else
 253     g_object_set (p->obj, p->spec->name, (float) adj->value, NULL);
 254 }
 255
 256 static void
 257 float_changed (GObject *object, GParamSpec *pspec, gpointer data)
 258 {
 259   GtkAdjustment *adj = GTK_ADJUSTMENT (data);
 260   GValue val = { 0, };
 261
 262   g_value_init (&val, G_TYPE_FLOAT);
 263   get_property_value (object, pspec, &val);
 264
 265   if (g_value_get_float (&val) != (float) adj->value)
 266     {
 267       block_controller (G_OBJECT (adj));
 268       gtk_adjustment_set_value (adj, g_value_get_float (&val));
 269       unblock_controller (G_OBJECT (adj));
 270     }
 271
 272   g_value_unset (&val);
 273 }
 274
 275 static void
 276 double_modified (GtkAdjustment *adj, gpointer data)
 277 {
 278   ObjectProperty *p = data;
 279
 280   if (is_child_property (p->spec))
 281     {
 282       GtkWidget *widget = GTK_WIDGET (p->obj);
 283       GtkWidget *parent = gtk_widget_get_parent (widget);
 284
 285       gtk_container_child_set (GTK_CONTAINER (parent),
 286                                widget, p->spec->name, (double) adj->value, NULL);
 287     }
 288   else
 289     g_object_set (p->obj, p->spec->name, (double) adj->value, NULL);
 290 }
 291
 292 static void
 293 double_changed (GObject *object, GParamSpec *pspec, gpointer data)
 294 {
 295   GtkAdjustment *adj = GTK_ADJUSTMENT (data);
 296   GValue val = { 0, };
 297
 298   g_value_init (&val, G_TYPE_DOUBLE);
 299   get_property_value (object, pspec, &val);
 300
 301   if (g_value_get_double (&val) != adj->value)
 302     {
 303       block_controller (G_OBJECT (adj));
 304       gtk_adjustment_set_value (adj, g_value_get_double (&val));
 305       unblock_controller (G_OBJECT (adj));
 306     }
 307
 308   g_value_unset (&val);
 309 }
 310
 311 static void
 312 string_modified (GtkEntry *entry, gpointer data)
 313 {
 314   ObjectProperty *p = data;
 315   const gchar *text;
 316
 317   text = gtk_entry_get_text (entry);
 318
 319   if (is_child_property (p->spec))
 320     {
 321       GtkWidget *widget = GTK_WIDGET (p->obj);
 322       GtkWidget *parent = gtk_widget_get_parent (widget);
 323
 324       gtk_container_child_set (GTK_CONTAINER (parent),
 325                                widget, p->spec->name, text, NULL);
 326     }
 327   else
 328     g_object_set (p->obj, p->spec->name, text, NULL);
 329 }
 330
 331 static void
 332 string_changed (GObject *object, GParamSpec *pspec, gpointer data)
 333 {
 334   GtkEntry *entry = GTK_ENTRY (data);
 335   GValue val = { 0, };
 336   const gchar *str;
 337   const gchar *text;
 338
 339   g_value_init (&val, G_TYPE_STRING);
 340   get_property_value (object, pspec, &val);
 341
 342   str = g_value_get_string (&val);
 343   if (str == NULL)
 344     str = "";
 345   text = gtk_entry_get_text (entry);
 346
 347   if (strcmp (str, text) != 0)
 348     {
 349       block_controller (G_OBJECT (entry));
 350       gtk_entry_set_text (entry, str);
 351       unblock_controller (G_OBJECT (entry));
 352     }
 353
 354   g_value_unset (&val);
 355 }
 356
 357 static void
 358 bool_modified (GtkToggleButton *tb, gpointer data)
 359 {
 360   ObjectProperty *p = data;
 361
 362   if (is_child_property (p->spec))
 363     {
 364       GtkWidget *widget = GTK_WIDGET (p->obj);
 365       GtkWidget *parent = gtk_widget_get_parent (widget);
 366
 367       gtk_container_child_set (GTK_CONTAINER (parent),
 368                                widget, p->spec->name, (int) tb->active, NULL);
 369     }
 370   else
 371     g_object_set (p->obj, p->spec->name, (int) tb->active, NULL);
 372 }
 373
 374 static void
 375 bool_changed (GObject *object, GParamSpec *pspec, gpointer data)
 376 {
 377   GtkToggleButton *tb = GTK_TOGGLE_BUTTON (data);
 378   GtkWidget *child;
 379   GValue val = { 0, };
 380
 381   g_value_init (&val, G_TYPE_BOOLEAN);
 382   get_property_value (object, pspec, &val);
 383
 384   if (g_value_get_boolean (&val) != tb->active)
 385     {
 386       block_controller (G_OBJECT (tb));
 387       gtk_toggle_button_set_active (tb, g_value_get_boolean (&val));
 388       unblock_controller (G_OBJECT (tb));
 389     }
 390
 391   child = gtk_bin_get_child (GTK_BIN (tb));
 392   gtk_label_set_text (GTK_LABEL (child),
 393                       g_value_get_boolean (&val) ? "TRUE" : "FALSE");
 394
 395   g_value_unset (&val);
 396 }
 397
 398
 399 static void
 400 enum_modified (GtkComboBox *cb, 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_combo_box_get_active (cb);
 409
 410
 411   if (is_child_property (p->spec))
 412     {
 413       GtkWidget *widget = GTK_WIDGET (p->obj);
 414       GtkWidget *parent = gtk_widget_get_parent (widget);
 415
 416       gtk_container_child_set (GTK_CONTAINER (parent),
 417                                widget, p->spec->name, eclass->values[i].value, NULL);
 418     }
 419   else
 420     g_object_set (p->obj, p->spec->name, eclass->values[i].value, NULL);
 421 }
 422
 423 static void
 424 enum_changed (GObject *object, GParamSpec *pspec, gpointer data)
 425 {
 426   GtkComboBox *cb = GTK_COMBO_BOX (data);
 427   GValue val = { 0, };
 428   GEnumClass *eclass;
 429   gint i;
 430
 431   eclass = G_ENUM_CLASS (g_type_class_peek (pspec->value_type));
 432
 433   g_value_init (&val, pspec->value_type);
 434   get_property_value (object, pspec, &val);
 435
 436   i = 0;
 437   while (i < eclass->n_values)
 438     {
 439       if (eclass->values[i].value == g_value_get_enum (&val))
 440         break;
 441       ++i;
 442     }
 443
 444   if (gtk_combo_box_get_active (cb) != i)
 445     {
 446       block_controller (G_OBJECT (cb));
 447       gtk_combo_box_set_active (cb, i);
 448       unblock_controller (G_OBJECT (cb));
 449     }
 450
 451   g_value_unset (&val);
 452
 453 }
 454
 455 static void
 456 flags_modified (GtkCheckButton *button, gpointer data)
 457 {
 458   ObjectProperty *p = data;
 459   gboolean active;
 460   GFlagsClass *fclass;
 461   guint flags;
 462   gint i;
 463
 464   fclass = G_FLAGS_CLASS (g_type_class_peek (p->spec->value_type));
 465
 466   active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
 467   i = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (button), "index"));
 468
 469   if (is_child_property (p->spec))
 470     {
 471       GtkWidget *widget = GTK_WIDGET (p->obj);
 472       GtkWidget *parent = gtk_widget_get_parent (widget);
 473
 474       gtk_container_child_get (GTK_CONTAINER (parent),
 475                                widget, p->spec->name, &flags, NULL);
 476       if (active)
 477         flags |= fclass->values[i].value;
 478       else
 479         flags &= ~fclass->values[i].value;
 480
 481       gtk_container_child_set (GTK_CONTAINER (parent),
 482                                widget, p->spec->name, flags, NULL);
 483     }
 484   else
 485     {
 486       g_object_get (p->obj, p->spec->name, &flags, NULL);
 487
 488       if (active)
 489         flags |= fclass->values[i].value;
 490       else
 491         flags &= ~fclass->values[i].value;
 492
 493       g_object_set (p->obj, p->spec->name, flags, NULL);
 494     }
 495 }
 496
 497 static void
 498 flags_changed (GObject *object, GParamSpec *pspec, gpointer data)
 499 {
 500   GList *children, *c;
 501   GValue val = { 0, };
 502   GFlagsClass *fclass;
 503   guint flags;
 504   gint i;
 505
 506   fclass = G_FLAGS_CLASS (g_type_class_peek (pspec->value_type));
 507
 508   g_value_init (&val, pspec->value_type);
 509   get_property_value (object, pspec, &val);
 510   flags = g_value_get_flags (&val);
 511   g_value_unset (&val);
 512
 513   children = gtk_container_get_children (GTK_CONTAINER (data));
 514
 515   for (c = children, i = 0; c; c = c->next, i++)
 516     {
 517       block_controller (G_OBJECT (c->data));
 518       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (c->data),
 519                                     (fclass->values[i].value & flags) != 0);
 520       unblock_controller (G_OBJECT (c->data));
 521     }
 522
 523   g_list_free (children);
 524 }
 525
 526 static gunichar
 527 unichar_get_value (GtkEntry *entry)
 528 {
 529   const gchar *text = gtk_entry_get_text (entry);
 530
 531   if (text[0])
 532     return g_utf8_get_char (text);
 533   else
 534     return 0;
 535 }
 536
 537 static void
 538 unichar_modified (GtkEntry *entry, gpointer data)
 539 {
 540   ObjectProperty *p = data;
 541   gunichar val = unichar_get_value (entry);
 542
 543   if (is_child_property (p->spec))
 544     {
 545       GtkWidget *widget = GTK_WIDGET (p->obj);
 546       GtkWidget *parent = gtk_widget_get_parent (widget);
 547
 548       gtk_container_child_set (GTK_CONTAINER (parent),
 549                                widget, p->spec->name, val, NULL);
 550     }
 551   else
 552     g_object_set (p->obj, p->spec->name, val, NULL);
 553 }
 554
 555 static void
 556 unichar_changed (GObject *object, GParamSpec *pspec, gpointer data)
 557 {
 558   GtkEntry *entry = GTK_ENTRY (data);
 559   gunichar new_val;
 560   gunichar old_val = unichar_get_value (entry);
 561   GValue val = { 0, };
 562   gchar buf[7];
 563   gint len;
 564
 565   g_value_init (&val, pspec->value_type);
 566   get_property_value (object, pspec, &val);
 567   new_val = (gunichar)g_value_get_uint (&val);
 568
 569   if (new_val != old_val)
 570     {
 571       if (!new_val)
 572         len = 0;
 573       else
 574         len = g_unichar_to_utf8 (new_val, buf);
 575
 576       buf[len] = '\0';
 577
 578       block_controller (G_OBJECT (entry));
 579       gtk_entry_set_text (entry, buf);
 580       unblock_controller (G_OBJECT (entry));
 581     }
 582 }
 583
 584 static void
 585 pointer_changed (GObject *object, GParamSpec *pspec, gpointer data)
 586 {
 587   GtkLabel *label = GTK_LABEL (data);
 588   gchar *str;
 589   gpointer ptr;
 590
 591   g_object_get (object, pspec->name, &ptr, NULL);
 592
 593   str = g_strdup_printf ("Pointer: %p", ptr);
 594   gtk_label_set_text (label, str);
 595   g_free (str);
 596 }
 597
 598 static gchar *
 599 object_label (GObject *obj, GParamSpec *pspec)
 600 {
 601   const gchar *name;
 602
 603   if (obj)
 604     name = g_type_name (G_TYPE_FROM_INSTANCE (obj));
 605   else if (pspec)
 606     name = g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec));
 607   else
 608     name = "unknown";
 609   return g_strdup_printf ("Object: %p (%s)", obj, name);
 610 }
 611
 612 static void
 613 object_changed (GObject *object, GParamSpec *pspec, gpointer data)
 614 {
 615   GtkWidget *label, *button;
 616   gchar *str;
 617   GObject *obj;
 618
 619   GList *children = gtk_container_get_children (GTK_CONTAINER (data));
 620   label = GTK_WIDGET (children->data);
 621   button = GTK_WIDGET (children->next->data);
 622   g_object_get (object, pspec->name, &obj, NULL);
 623   g_list_free (children);
 624
 625   str = object_label (obj, pspec);
 626
 627   gtk_label_set_text (GTK_LABEL (label), str);
 628   gtk_widget_set_sensitive (button, G_IS_OBJECT (obj));
 629
 630   if (obj)
 631     g_object_unref (obj);
 632
 633   g_free (str);
 634 }
 635
 636 static void
 637 model_destroy (gpointer data)
 638 {
 639   g_object_steal_data (data, "model-object");
 640   gtk_widget_destroy (data);
 641 }
 642
 643 static void
 644 window_destroy (gpointer data)
 645 {
 646   g_object_steal_data (data, "prop-editor-win");
 647 }
 648
 649 static void
 650 object_properties (GtkWidget *button,
 651                    GObject   *object)
 652 {
 653   gchar *name;
 654   GObject *obj;
 655
 656   name = (gchar *) g_object_get_data (G_OBJECT (button), "property-name");
 657   g_object_get (object, name, &obj, NULL);
 658   if (G_IS_OBJECT (obj))
 659     create_prop_editor (obj, 0);
 660 }
 661
 662 static void
 663 color_modified (GtkColorButton *cb, gpointer data)
 664 {
 665   ObjectProperty *p = data;
 666   GdkColor color;
 667
 668   gtk_color_button_get_color (cb, &color);
 669
 670   if (is_child_property (p->spec))
 671     {
 672       GtkWidget *widget = GTK_WIDGET (p->obj);
 673       GtkWidget *parent = gtk_widget_get_parent (widget);
 674
 675       gtk_container_child_set (GTK_CONTAINER (parent),
 676                                widget, p->spec->name, &color, NULL);
 677     }
 678   else
 679     g_object_set (p->obj, p->spec->name, &color, NULL);
 680 }
 681
 682 static void
 683 color_changed (GObject *object, GParamSpec *pspec, gpointer data)
 684 {
 685   GtkColorButton *cb = GTK_COLOR_BUTTON (data);
 686   GValue val = { 0, };
 687   GdkColor *color;
 688   GdkColor cb_color;
 689
 690   g_value_init (&val, GDK_TYPE_COLOR);
 691   get_property_value (object, pspec, &val);
 692
 693   color = g_value_get_boxed (&val);
 694   gtk_color_button_get_color (cb, &cb_color);
 695
 696   if (color != NULL && !gdk_color_equal (color, &cb_color))
 697     {
 698       block_controller (G_OBJECT (cb));
 699       gtk_color_button_set_color (cb, color);
 700       unblock_controller (G_OBJECT (cb));
 701     }
 702
 703   g_value_unset (&val);
 704 }
 705
 706 static GtkWidget *
 707 property_widget (GObject    *object,
 708                  GParamSpec *spec,
 709                  gboolean    can_modify)
 710 {
 711   GtkWidget *prop_edit;
 712   GtkAdjustment *adj;
 713   gchar *msg;
 714   GType type = G_PARAM_SPEC_TYPE (spec);
 715
 716   if (type == G_TYPE_PARAM_INT)
 717     {
 718       adj = gtk_adjustment_new (G_PARAM_SPEC_INT (spec)->default_value,
 719                                 G_PARAM_SPEC_INT (spec)->minimum,
 720                                 G_PARAM_SPEC_INT (spec)->maximum,
 721                                 1,
 722                                 MAX ((G_PARAM_SPEC_INT (spec)->maximum - G_PARAM_SPEC_INT (spec)->minimum) / 10, 1),
 723                                 0.0);
 724
 725       prop_edit = gtk_spin_button_new (adj, 1.0, 0);
 726
 727       g_object_connect_property (object, spec,
 728                                  G_CALLBACK (int_changed),
 729                                  adj, G_OBJECT (adj));
 730
 731       if (can_modify)
 732         connect_controller (G_OBJECT (adj), "value_changed",
 733                             object, spec, G_CALLBACK (int_modified));
 734     }
 735   else if (type == G_TYPE_PARAM_UINT)
 736     {
 737       adj = gtk_adjustment_new (G_PARAM_SPEC_UINT (spec)->default_value,
 738                                 G_PARAM_SPEC_UINT (spec)->minimum,
 739                                 G_PARAM_SPEC_UINT (spec)->maximum,
 740                                 1,
 741                                 MAX ((G_PARAM_SPEC_UINT (spec)->maximum - G_PARAM_SPEC_UINT (spec)->minimum) / 10, 1),
 742                                 0.0);
 743
 744       prop_edit = gtk_spin_button_new (adj, 1.0, 0);
 745
 746       g_object_connect_property (object, spec,
 747                                  G_CALLBACK (uint_changed),
 748                                  adj, G_OBJECT (adj));
 749
 750       if (can_modify)
 751         connect_controller (G_OBJECT (adj), "value_changed",
 752                             object, spec, G_CALLBACK (uint_modified));
 753     }
 754   else if (type == G_TYPE_PARAM_FLOAT)
 755     {
 756       adj = gtk_adjustment_new (G_PARAM_SPEC_FLOAT (spec)->default_value,
 757                                 G_PARAM_SPEC_FLOAT (spec)->minimum,
 758                                 G_PARAM_SPEC_FLOAT (spec)->maximum,
 759                                 0.1,
 760                                 MAX ((G_PARAM_SPEC_FLOAT (spec)->maximum - G_PARAM_SPEC_FLOAT (spec)->minimum) / 10, 0.1),
 761                                 0.0);
 762
 763       prop_edit = gtk_spin_button_new (adj, 0.1, 2);
 764
 765       g_object_connect_property (object, spec,
 766                                  G_CALLBACK (float_changed),
 767                                  adj, G_OBJECT (adj));
 768
 769       if (can_modify)
 770         connect_controller (G_OBJECT (adj), "value_changed",
 771                             object, spec, G_CALLBACK (float_modified));
 772     }
 773   else if (type == G_TYPE_PARAM_DOUBLE)
 774     {
 775       adj = gtk_adjustment_new (G_PARAM_SPEC_DOUBLE (spec)->default_value,
 776                                 G_PARAM_SPEC_DOUBLE (spec)->minimum,
 777                                 G_PARAM_SPEC_DOUBLE (spec)->maximum,
 778                                 0.1,
 779                                 MAX ((G_PARAM_SPEC_DOUBLE (spec)->maximum - G_PARAM_SPEC_DOUBLE (spec)->minimum) / 10, 0.1),
 780                                 0.0);
 781
 782       prop_edit = gtk_spin_button_new (adj, 0.1, 2);
 783
 784       g_object_connect_property (object, spec,
 785                                  G_CALLBACK (double_changed),
 786                                  adj, G_OBJECT (adj));
 787
 788       if (can_modify)
 789         connect_controller (G_OBJECT (adj), "value_changed",
 790                             object, spec, G_CALLBACK (double_modified));
 791     }
 792   else if (type == G_TYPE_PARAM_STRING)
 793     {
 794       prop_edit = gtk_entry_new ();
 795
 796       g_object_connect_property (object, spec,
 797                                  G_CALLBACK (string_changed),
 798                                  prop_edit, G_OBJECT (prop_edit));
 799
 800       if (can_modify)
 801         connect_controller (G_OBJECT (prop_edit), "changed",
 802                             object, spec, G_CALLBACK (string_modified));
 803     }
 804   else if (type == G_TYPE_PARAM_BOOLEAN)
 805     {
 806       prop_edit = gtk_toggle_button_new_with_label ("");
 807
 808       g_object_connect_property (object, spec,
 809                                  G_CALLBACK (bool_changed),
 810                                  prop_edit, G_OBJECT (prop_edit));
 811
 812       if (can_modify)
 813         connect_controller (G_OBJECT (prop_edit), "toggled",
 814                             object, spec, G_CALLBACK (bool_modified));
 815     }
 816   else if (type == G_TYPE_PARAM_ENUM)
 817     {
 818       {
 819         GEnumClass *eclass;
 820         gint j;
 821
 822         prop_edit = gtk_combo_box_new_text ();
 823
 824         eclass = G_ENUM_CLASS (g_type_class_ref (spec->value_type));
 825
 826         j = 0;
 827         while (j < eclass->n_values)
 828           {
 829             gtk_combo_box_append_text (GTK_COMBO_BOX (prop_edit),
 830                                        eclass->values[j].value_name);
 831             ++j;
 832           }
 833
 834         g_type_class_unref (eclass);
 835
 836         g_object_connect_property (object, spec,
 837                                    G_CALLBACK (enum_changed),
 838                                    prop_edit, G_OBJECT (prop_edit));
 839
 840         if (can_modify)
 841           connect_controller (G_OBJECT (prop_edit), "changed",
 842                               object, spec, G_CALLBACK (enum_modified));
 843       }
 844     }
 845   else if (type == G_TYPE_PARAM_FLAGS)
 846     {
 847       {
 848         GFlagsClass *fclass;
 849         gint j;
 850
 851         prop_edit = gtk_vbox_new (FALSE, 0);
 852
 853         fclass = G_FLAGS_CLASS (g_type_class_ref (spec->value_type));
 854
 855         for (j = 0; j < fclass->n_values; j++)
 856           {
 857             GtkWidget *b;
 858
 859             b = gtk_check_button_new_with_label (fclass->values[j].value_name);
 860             g_object_set_data (G_OBJECT (b), "index", GINT_TO_POINTER (j));
 861             gtk_widget_show (b);
 862             gtk_box_pack_start (GTK_BOX (prop_edit), b, FALSE, FALSE, 0);
 863             if (can_modify)
 864               connect_controller (G_OBJECT (b), "toggled",
 865                                   object, spec, G_CALLBACK (flags_modified));
 866           }
 867
 868         g_type_class_unref (fclass);
 869
 870         g_object_connect_property (object, spec,
 871                                    G_CALLBACK (flags_changed),
 872                                    prop_edit, G_OBJECT (prop_edit));
 873       }
 874     }
 875   else if (type == G_TYPE_PARAM_UNICHAR)
 876     {
 877       prop_edit = gtk_entry_new ();
 878       gtk_entry_set_max_length (GTK_ENTRY (prop_edit), 1);
 879
 880       g_object_connect_property (object, spec,
 881                                  G_CALLBACK (unichar_changed),
 882                                  prop_edit, G_OBJECT (prop_edit));
 883
 884       if (can_modify)
 885         connect_controller (G_OBJECT (prop_edit), "changed",
 886                             object, spec, G_CALLBACK (unichar_modified));
 887     }
 888   else if (type == G_TYPE_PARAM_POINTER)
 889     {
 890       prop_edit = gtk_label_new ("");
 891
 892       g_object_connect_property (object, spec,
 893                                  G_CALLBACK (pointer_changed),
 894                                  prop_edit, G_OBJECT (prop_edit));
 895     }
 896   else if (type == G_TYPE_PARAM_OBJECT)
 897     {
 898       GtkWidget *label, *button;
 899
 900       prop_edit = gtk_hbox_new (FALSE, 5);
 901
 902       label = gtk_label_new ("");
 903       button = gtk_button_new_with_label ("Properties");
 904       g_object_set_data (G_OBJECT (button), "property-name", spec->name);
 905       g_signal_connect (button, "clicked",
 906                         G_CALLBACK (object_properties),
 907                         object);
 908
 909       gtk_container_add (GTK_CONTAINER (prop_edit), label);
 910       gtk_container_add (GTK_CONTAINER (prop_edit), button);
 911
 912       g_object_connect_property (object, spec,
 913                                  G_CALLBACK (object_changed),
 914                                  prop_edit, G_OBJECT (label));
 915     }
 916   else if (type == G_TYPE_PARAM_BOXED &&
 917            G_PARAM_SPEC_VALUE_TYPE (spec) == GDK_TYPE_COLOR)
 918     {
 919       prop_edit = gtk_color_button_new ();
 920
 921       g_object_connect_property (object, spec,
 922                                  G_CALLBACK (color_changed),
 923                                  prop_edit, G_OBJECT (prop_edit));
 924
 925       if (can_modify)
 926         connect_controller (G_OBJECT (prop_edit), "color-set",
 927                             object, spec, G_CALLBACK (color_modified));
 928     }
 929   else
 930     {
 931       msg = g_strdup_printf ("uneditable property type: %s",
 932                              g_type_name (G_PARAM_SPEC_TYPE (spec)));
 933       prop_edit = gtk_label_new (msg);
 934       g_free (msg);
 935       gtk_misc_set_alignment (GTK_MISC (prop_edit), 0.0, 0.5);
 936     }
 937
 938   return prop_edit;
 939 }
 940
 941 static GtkWidget *
 942 properties_from_type (GObject *object,
 943                       GType    type)
 944 {
 945   GtkWidget *prop_edit;
 946   GtkWidget *label;
 947   GtkWidget *sw;
 948   GtkWidget *vbox;
 949   GtkWidget *table;
 950   GParamSpec **specs;
 951   guint n_specs;
 952   int i;
 953
 954   if (G_TYPE_IS_INTERFACE (type))
 955     {
 956       gpointer vtable = g_type_default_interface_peek (type);
 957       specs = g_object_interface_list_properties (vtable, &n_specs);
 958     }
 959   else
 960     {
 961       GObjectClass *class = G_OBJECT_CLASS (g_type_class_peek (type));
 962       specs = g_object_class_list_properties (class, &n_specs);
 963     }
 964
 965   if (n_specs == 0) {
 966     g_free (specs);
 967     return NULL;
 968   }
 969
 970   table = gtk_table_new (n_specs, 2, FALSE);
 971   gtk_table_set_col_spacing (GTK_TABLE (table), 0, 10);
 972   gtk_table_set_row_spacings (GTK_TABLE (table), 3);
 973
 974   i = 0;
 975   while (i < n_specs)
 976     {
 977       GParamSpec *spec = specs[i];
 978       gboolean can_modify;
 979
 980       prop_edit = NULL;
 981
 982       can_modify = ((spec->flags & G_PARAM_WRITABLE) != 0 &&
 983                     (spec->flags & G_PARAM_CONSTRUCT_ONLY) == 0);
 984
 985       if ((spec->flags & G_PARAM_READABLE) == 0)
 986         {
 987           /* can't display unreadable properties */
 988           ++i;
 989           continue;
 990         }
 991
 992       if (spec->owner_type != type)
 993         {
 994           /* we're only interested in params of type */
 995           ++i;
 996           continue;
 997         }
 998
 999       label = gtk_label_new (g_param_spec_get_nick (spec));
1000       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1001       gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, i, i + 1);
1002
1003       prop_edit = property_widget (object, spec, can_modify);
1004       gtk_table_attach_defaults (GTK_TABLE (table), prop_edit, 1, 2, i, i + 1);
1005
1006       if (prop_edit)
1007         {
1008           if (!can_modify)
1009             gtk_widget_set_sensitive (prop_edit, FALSE);
1010
1011           if (g_param_spec_get_blurb (spec))
1012             gtk_widget_set_tooltip_text (prop_edit, g_param_spec_get_blurb (spec));
1013
1014           /* set initial value */
1015           g_object_notify (object, spec->name);
1016         }
1017
1018       ++i;
1019     }
1020
1021
1022   vbox = gtk_vbox_new (FALSE, 0);
1023   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
1024
1025   sw = gtk_scrolled_window_new (NULL, NULL);
1026   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
1027                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1028
1029   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), vbox);
1030
1031   g_free (specs);
1032
1033   return sw;
1034 }
1035
1036 static GtkWidget *
1037 child_properties_from_object (GObject *object)
1038 {
1039   GtkWidget *prop_edit;
1040   GtkWidget *label;
1041   GtkWidget *sw;
1042   GtkWidget *vbox;
1043   GtkWidget *table;
1044   GtkWidget *parent;
1045   GParamSpec **specs;
1046   guint n_specs;
1047   gint i;
1048
1049   if (!GTK_IS_WIDGET (object))
1050     return NULL;
1051
1052   parent = gtk_widget_get_parent (GTK_WIDGET (object));
1053
1054   if (!parent)
1055     return NULL;
1056
1057   specs = gtk_container_class_list_child_properties (G_OBJECT_GET_CLASS (parent), &n_specs);
1058
1059   table = gtk_table_new (n_specs, 2, FALSE);
1060   gtk_table_set_col_spacing (GTK_TABLE (table), 0, 10);
1061   gtk_table_set_row_spacings (GTK_TABLE (table), 3);
1062
1063   i = 0;
1064   while (i < n_specs)
1065     {
1066       GParamSpec *spec = specs[i];
1067       gboolean can_modify;
1068
1069       prop_edit = NULL;
1070
1071       can_modify = ((spec->flags & G_PARAM_WRITABLE) != 0 &&
1072                     (spec->flags & G_PARAM_CONSTRUCT_ONLY) == 0);
1073
1074       if ((spec->flags & G_PARAM_READABLE) == 0)
1075         {
1076           /* can't display unreadable properties */
1077           ++i;
1078           continue;
1079         }
1080
1081       label = gtk_label_new (g_param_spec_get_nick (spec));
1082       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1083       gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, i, i + 1);
1084
1085       mark_child_property (spec);
1086       prop_edit = property_widget (object, spec, can_modify);
1087       gtk_table_attach_defaults (GTK_TABLE (table), prop_edit, 1, 2, i, i + 1);
1088
1089       if (prop_edit)
1090         {
1091           if (!can_modify)
1092             gtk_widget_set_sensitive (prop_edit, FALSE);
1093
1094           if (g_param_spec_get_blurb (spec))
1095             gtk_widget_set_tooltip_text (prop_edit, g_param_spec_get_blurb (spec));
1096
1097           /* set initial value */
1098           gtk_widget_child_notify (GTK_WIDGET (object), spec->name);
1099         }
1100
1101       ++i;
1102     }
1103
1104   vbox = gtk_vbox_new (FALSE, 0);
1105   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
1106
1107   sw = gtk_scrolled_window_new (NULL, NULL);
1108   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
1109                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1110
1111   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), vbox);
1112
1113   g_free (specs);
1114
1115   return sw;
1116 }
1117
1118 static void
1119 child_properties (GtkWidget *button,
1120                   GObject   *object)
1121 {
1122   create_prop_editor (object, 0);
1123 }
1124
1125 static GtkWidget *
1126 children_from_object (GObject *object)
1127 {
1128   GList *children, *c;
1129   GtkWidget *table, *label, *prop_edit, *button, *vbox, *sw;
1130   gchar *str;
1131   gint i;
1132
1133   if (!GTK_IS_CONTAINER (object))
1134     return NULL;
1135
1136   children = gtk_container_get_children (GTK_CONTAINER (object));
1137
1138   table = gtk_table_new (g_list_length (children), 2, FALSE);
1139   gtk_table_set_col_spacing (GTK_TABLE (table), 0, 10);
1140   gtk_table_set_row_spacings (GTK_TABLE (table), 3);
1141
1142   for (c = children, i = 0; c; c = c->next, i++)
1143     {
1144       object = c->data;
1145
1146       label = gtk_label_new ("Child");
1147       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1148       gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, i, i + 1);
1149
1150       prop_edit = gtk_hbox_new (FALSE, 5);
1151
1152       str = object_label (object, NULL);
1153       label = gtk_label_new (str);
1154       g_free (str);
1155       button = gtk_button_new_with_label ("Properties");
1156       g_signal_connect (button, "clicked",
1157                         G_CALLBACK (child_properties),
1158                         object);
1159
1160       gtk_container_add (GTK_CONTAINER (prop_edit), label);
1161       gtk_container_add (GTK_CONTAINER (prop_edit), button);
1162
1163       gtk_table_attach_defaults (GTK_TABLE (table), prop_edit, 1, 2, i, i + 1);
1164     }
1165
1166   vbox = gtk_vbox_new (FALSE, 0);
1167   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
1168
1169   sw = gtk_scrolled_window_new (NULL, NULL);
1170   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
1171                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1172
1173   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), vbox);
1174
1175   g_list_free (children);
1176
1177   return sw;
1178 }
1179
1180 static GtkWidget *
1181 cells_from_object (GObject *object)
1182 {
1183   GList *cells, *c;
1184   GtkWidget *table, *label, *prop_edit, *button, *vbox, *sw;
1185   gchar *str;
1186   gint i;
1187
1188   if (!GTK_IS_CELL_LAYOUT (object))
1189     return NULL;
1190
1191   cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (object));
1192
1193   table = gtk_table_new (g_list_length (cells), 2, FALSE);
1194   gtk_table_set_col_spacing (GTK_TABLE (table), 0, 10);
1195   gtk_table_set_row_spacings (GTK_TABLE (table), 3);
1196
1197   for (c = cells, i = 0; c; c = c->next, i++)
1198     {
1199       object = c->data;
1200
1201       label = gtk_label_new ("Cell");
1202       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1203       gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, i, i + 1);
1204
1205       prop_edit = gtk_hbox_new (FALSE, 5);
1206
1207       str = object_label (object, NULL);
1208       label = gtk_label_new (str);
1209       g_free (str);
1210       button = gtk_button_new_with_label ("Properties");
1211       g_signal_connect (button, "clicked",
1212                         G_CALLBACK (child_properties),
1213                         object);
1214
1215       gtk_container_add (GTK_CONTAINER (prop_edit), label);
1216       gtk_container_add (GTK_CONTAINER (prop_edit), button);
1217
1218       gtk_table_attach_defaults (GTK_TABLE (table), prop_edit, 1, 2, i, i + 1);
1219     }
1220
1221   vbox = gtk_vbox_new (FALSE, 0);
1222   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
1223
1224   sw = gtk_scrolled_window_new (NULL, NULL);
1225   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
1226                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1227
1228   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), vbox);
1229
1230   g_list_free (cells);
1231
1232   return sw;
1233 }
1234
1235 /* Pass zero for type if you want all properties */
1236 GtkWidget*
1237 create_prop_editor (GObject   *object,
1238                     GType      type)
1239 {
1240   GtkWidget *win;
1241   GtkWidget *notebook;
1242   GtkWidget *properties;
1243   GtkWidget *label;
1244   gchar *title;
1245   GType *ifaces;
1246   guint n_ifaces;
1247
1248   if ((win = g_object_get_data (G_OBJECT (object), "prop-editor-win")))
1249     {
1250       gtk_window_present (GTK_WINDOW (win));
1251       return win;
1252     }
1253
1254   win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1255   if (GTK_IS_WIDGET (object))
1256     gtk_window_set_screen (GTK_WINDOW (win),
1257                            gtk_widget_get_screen (GTK_WIDGET (object)));
1258
1259   /* hold a weak ref to the object we're editing */
1260   g_object_set_data_full (G_OBJECT (object), "prop-editor-win", win, model_destroy);
1261   g_object_set_data_full (G_OBJECT (win), "model-object", object, window_destroy);
1262
1263   if (type == 0)
1264     {
1265       notebook = gtk_notebook_new ();
1266       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_LEFT);
1267
1268       gtk_container_add (GTK_CONTAINER (win), notebook);
1269
1270       type = G_TYPE_FROM_INSTANCE (object);
1271
1272       title = g_strdup_printf ("Properties of %s widget", g_type_name (type));
1273       gtk_window_set_title (GTK_WINDOW (win), title);
1274       g_free (title);
1275
1276       while (type)
1277         {
1278           properties = properties_from_type (object, type);
1279           if (properties)
1280             {
1281               label = gtk_label_new (g_type_name (type));
1282               gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
1283                                         properties, label);
1284             }
1285
1286           type = g_type_parent (type);
1287         }
1288
1289       ifaces = g_type_interfaces (G_TYPE_FROM_INSTANCE (object), &n_ifaces);
1290       while (n_ifaces--)
1291         {
1292           properties = properties_from_type (object, ifaces[n_ifaces]);
1293           if (properties)
1294             {
1295               label = gtk_label_new (g_type_name (ifaces[n_ifaces]));
1296               gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
1297                                         properties, label);
1298             }
1299         }
1300
1301       g_free (ifaces);
1302
1303       properties = child_properties_from_object (object);
1304       if (properties)
1305         {
1306           label = gtk_label_new ("Child properties");
1307           gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
1308                                     properties, label);
1309         }
1310
1311       properties = children_from_object (object);
1312       if (properties)
1313         {
1314           label = gtk_label_new ("Children");
1315           gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
1316                                     properties, label);
1317         }
1318
1319       properties = cells_from_object (object);
1320       if (properties)
1321         {
1322           label = gtk_label_new ("Cell renderers");
1323           gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
1324                                     properties, label);
1325         }
1326     }
1327   else
1328     {
1329       properties = properties_from_type (object, type);
1330       gtk_container_add (GTK_CONTAINER (win), properties);
1331       title = g_strdup_printf ("Properties of %s", g_type_name (type));
1332       gtk_window_set_title (GTK_WINDOW (win), title);
1333       g_free (title);
1334     }
1335
1336   gtk_window_set_default_size (GTK_WINDOW (win), -1, 400);
1337
1338   gtk_widget_show_all (win);
1339
1340   return win;
1341 }
1342