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 (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 -
 723                                                       G_PARAM_SPEC_INT (spec)->minimum) / 10, 1),
 724                                                 0.0));
 725
 726       prop_edit = gtk_spin_button_new (adj, 1.0, 0);
 727
 728       g_object_connect_property (object, spec,
 729                                  G_CALLBACK (int_changed),
 730                                  adj, G_OBJECT (adj));
 731
 732       if (can_modify)
 733         connect_controller (G_OBJECT (adj), "value_changed",
 734                             object, spec, G_CALLBACK (int_modified));
 735     }
 736   else if (type == G_TYPE_PARAM_UINT)
 737     {
 738       adj = GTK_ADJUSTMENT (
 739                             gtk_adjustment_new (G_PARAM_SPEC_UINT (spec)->default_value,
 740                                                 G_PARAM_SPEC_UINT (spec)->minimum,
 741                                                 G_PARAM_SPEC_UINT (spec)->maximum,
 742                                                 1,
 743                                                 MAX ((G_PARAM_SPEC_UINT (spec)->maximum -
 744                                                       G_PARAM_SPEC_UINT (spec)->minimum) / 10, 1),
 745                                                 0.0));
 746
 747       prop_edit = gtk_spin_button_new (adj, 1.0, 0);
 748
 749       g_object_connect_property (object, spec,
 750                                  G_CALLBACK (uint_changed),
 751                                  adj, G_OBJECT (adj));
 752
 753       if (can_modify)
 754         connect_controller (G_OBJECT (adj), "value_changed",
 755                             object, spec, G_CALLBACK (uint_modified));
 756     }
 757   else if (type == G_TYPE_PARAM_FLOAT)
 758     {
 759
 760       adj = GTK_ADJUSTMENT (gtk_adjustment_new (G_PARAM_SPEC_FLOAT (spec)->default_value,
 761                                                 G_PARAM_SPEC_FLOAT (spec)->minimum,
 762                                                 G_PARAM_SPEC_FLOAT (spec)->maximum,
 763                                                 0.1,
 764                                                 MAX ((G_PARAM_SPEC_FLOAT (spec)->maximum -
 765                                                       G_PARAM_SPEC_FLOAT (spec)->minimum) / 10, 0.1),
 766                                                 0.0));
 767
 768       prop_edit = gtk_spin_button_new (adj, 0.1, 2);
 769
 770       g_object_connect_property (object, spec,
 771                                  G_CALLBACK (float_changed),
 772                                  adj, G_OBJECT (adj));
 773
 774       if (can_modify)
 775         connect_controller (G_OBJECT (adj), "value_changed",
 776                             object, spec, G_CALLBACK (float_modified));
 777     }
 778   else if (type == G_TYPE_PARAM_DOUBLE)
 779     {
 780       adj = GTK_ADJUSTMENT (gtk_adjustment_new (G_PARAM_SPEC_DOUBLE (spec)->default_value,
 781                                                 G_PARAM_SPEC_DOUBLE (spec)->minimum,
 782                                                 G_PARAM_SPEC_DOUBLE (spec)->maximum,
 783                                                 0.1,
 784                                                 MAX ((G_PARAM_SPEC_DOUBLE (spec)->maximum -
 785                                                       G_PARAM_SPEC_DOUBLE (spec)->minimum) / 10, 0.1),
 786                                                 0.0));
 787
 788       prop_edit = gtk_spin_button_new (adj, 0.1, 2);
 789
 790       g_object_connect_property (object, spec,
 791                                  G_CALLBACK (double_changed),
 792                                  adj, G_OBJECT (adj));
 793
 794       if (can_modify)
 795         connect_controller (G_OBJECT (adj), "value_changed",
 796                             object, spec, G_CALLBACK (double_modified));
 797     }
 798   else if (type == G_TYPE_PARAM_STRING)
 799     {
 800       prop_edit = gtk_entry_new ();
 801
 802       g_object_connect_property (object, spec,
 803                                  G_CALLBACK (string_changed),
 804                                  prop_edit, G_OBJECT (prop_edit));
 805
 806       if (can_modify)
 807         connect_controller (G_OBJECT (prop_edit), "changed",
 808                             object, spec, G_CALLBACK (string_modified));
 809     }
 810   else if (type == G_TYPE_PARAM_BOOLEAN)
 811     {
 812       prop_edit = gtk_toggle_button_new_with_label ("");
 813
 814       g_object_connect_property (object, spec,
 815                                  G_CALLBACK (bool_changed),
 816                                  prop_edit, G_OBJECT (prop_edit));
 817
 818       if (can_modify)
 819         connect_controller (G_OBJECT (prop_edit), "toggled",
 820                             object, spec, G_CALLBACK (bool_modified));
 821     }
 822   else if (type == G_TYPE_PARAM_ENUM)
 823     {
 824       {
 825         GEnumClass *eclass;
 826         gint j;
 827
 828         prop_edit = gtk_combo_box_new_text ();
 829
 830         eclass = G_ENUM_CLASS (g_type_class_ref (spec->value_type));
 831
 832         j = 0;
 833         while (j < eclass->n_values)
 834           {
 835             gtk_combo_box_append_text (GTK_COMBO_BOX (prop_edit),
 836                                        eclass->values[j].value_name);
 837             ++j;
 838           }
 839
 840         g_type_class_unref (eclass);
 841
 842         g_object_connect_property (object, spec,
 843                                    G_CALLBACK (enum_changed),
 844                                    prop_edit, G_OBJECT (prop_edit));
 845
 846         if (can_modify)
 847           connect_controller (G_OBJECT (prop_edit), "changed",
 848                               object, spec, G_CALLBACK (enum_modified));
 849       }
 850     }
 851   else if (type == G_TYPE_PARAM_FLAGS)
 852     {
 853       {
 854         GFlagsClass *fclass;
 855         gint j;
 856
 857         prop_edit = gtk_vbox_new (FALSE, 0);
 858
 859         fclass = G_FLAGS_CLASS (g_type_class_ref (spec->value_type));
 860
 861         for (j = 0; j < fclass->n_values; j++)
 862           {
 863             GtkWidget *b;
 864
 865             b = gtk_check_button_new_with_label (fclass->values[j].value_name);
 866             g_object_set_data (G_OBJECT (b), "index", GINT_TO_POINTER (j));
 867             gtk_widget_show (b);
 868             gtk_box_pack_start (GTK_BOX (prop_edit), b, FALSE, FALSE, 0);
 869             if (can_modify)
 870               connect_controller (G_OBJECT (b), "toggled",
 871                                   object, spec, G_CALLBACK (flags_modified));
 872           }
 873
 874         g_type_class_unref (fclass);
 875
 876         g_object_connect_property (object, spec,
 877                                    G_CALLBACK (flags_changed),
 878                                    prop_edit, G_OBJECT (prop_edit));
 879       }
 880     }
 881   else if (type == G_TYPE_PARAM_UNICHAR)
 882     {
 883       prop_edit = gtk_entry_new ();
 884       gtk_entry_set_max_length (GTK_ENTRY (prop_edit), 1);
 885
 886       g_object_connect_property (object, spec,
 887                                  G_CALLBACK (unichar_changed),
 888                                  prop_edit, G_OBJECT (prop_edit));
 889
 890       if (can_modify)
 891         connect_controller (G_OBJECT (prop_edit), "changed",
 892                             object, spec, G_CALLBACK (unichar_modified));
 893     }
 894   else if (type == G_TYPE_PARAM_POINTER)
 895     {
 896       prop_edit = gtk_label_new ("");
 897
 898       g_object_connect_property (object, spec,
 899                                  G_CALLBACK (pointer_changed),
 900                                  prop_edit, G_OBJECT (prop_edit));
 901     }
 902   else if (type == G_TYPE_PARAM_OBJECT)
 903     {
 904       GtkWidget *label, *button;
 905
 906       prop_edit = gtk_hbox_new (FALSE, 5);
 907
 908       label = gtk_label_new ("");
 909       button = gtk_button_new_with_label ("Properties");
 910       g_object_set_data (G_OBJECT (button), "property-name", spec->name);
 911       g_signal_connect (button, "clicked",
 912                         G_CALLBACK (object_properties),
 913                         object);
 914
 915       gtk_container_add (GTK_CONTAINER (prop_edit), label);
 916       gtk_container_add (GTK_CONTAINER (prop_edit), button);
 917
 918       g_object_connect_property (object, spec,
 919                                  G_CALLBACK (object_changed),
 920                                  prop_edit, G_OBJECT (label));
 921     }
 922   else if (type == G_TYPE_PARAM_BOXED &&
 923            G_PARAM_SPEC_VALUE_TYPE (spec) == GDK_TYPE_COLOR)
 924     {
 925       prop_edit = gtk_color_button_new ();
 926
 927       g_object_connect_property (object, spec,
 928                                  G_CALLBACK (color_changed),
 929                                  prop_edit, G_OBJECT (prop_edit));
 930
 931       if (can_modify)
 932         connect_controller (G_OBJECT (prop_edit), "color-set",
 933                             object, spec, G_CALLBACK (color_modified));
 934     }
 935   else
 936     {
 937       msg = g_strdup_printf ("uneditable property type: %s",
 938                              g_type_name (G_PARAM_SPEC_TYPE (spec)));
 939       prop_edit = gtk_label_new (msg);
 940       g_free (msg);
 941       gtk_misc_set_alignment (GTK_MISC (prop_edit), 0.0, 0.5);
 942     }
 943
 944   return prop_edit;
 945 }
 946
 947 static GtkWidget *
 948 properties_from_type (GObject *object,
 949                       GType    type)
 950 {
 951   GtkWidget *prop_edit;
 952   GtkWidget *label;
 953   GtkWidget *sw;
 954   GtkWidget *vbox;
 955   GtkWidget *table;
 956   GParamSpec **specs;
 957   guint n_specs;
 958   int i;
 959
 960   if (G_TYPE_IS_INTERFACE (type))
 961     {
 962       gpointer vtable = g_type_default_interface_peek (type);
 963       specs = g_object_interface_list_properties (vtable, &n_specs);
 964     }
 965   else
 966     {
 967       GObjectClass *class = G_OBJECT_CLASS (g_type_class_peek (type));
 968       specs = g_object_class_list_properties (class, &n_specs);
 969     }
 970
 971   if (n_specs == 0) {
 972     g_free (specs);
 973     return NULL;
 974   }
 975
 976   table = gtk_table_new (n_specs, 2, FALSE);
 977   gtk_table_set_col_spacing (GTK_TABLE (table), 0, 10);
 978   gtk_table_set_row_spacings (GTK_TABLE (table), 3);
 979
 980   i = 0;
 981   while (i < n_specs)
 982     {
 983       GParamSpec *spec = specs[i];
 984       gboolean can_modify;
 985
 986       prop_edit = NULL;
 987
 988       can_modify = ((spec->flags & G_PARAM_WRITABLE) != 0 &&
 989                     (spec->flags & G_PARAM_CONSTRUCT_ONLY) == 0);
 990
 991       if ((spec->flags & G_PARAM_READABLE) == 0)
 992         {
 993           /* can't display unreadable properties */
 994           ++i;
 995           continue;
 996         }
 997
 998       if (spec->owner_type != type)
 999         {
1000           /* we're only interested in params of type */
1001           ++i;
1002           continue;
1003         }
1004
1005       label = gtk_label_new (g_param_spec_get_nick (spec));
1006       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1007       gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, i, i + 1);
1008
1009       prop_edit = property_widget (object, spec, can_modify);
1010       gtk_table_attach_defaults (GTK_TABLE (table), prop_edit, 1, 2, i, i + 1);
1011
1012       if (prop_edit)
1013         {
1014           if (!can_modify)
1015             gtk_widget_set_sensitive (prop_edit, FALSE);
1016
1017           if (g_param_spec_get_blurb (spec))
1018             gtk_widget_set_tooltip_text (prop_edit, g_param_spec_get_blurb (spec));
1019
1020           /* set initial value */
1021           g_object_notify (object, spec->name);
1022         }
1023
1024       ++i;
1025     }
1026
1027
1028   vbox = gtk_vbox_new (FALSE, 0);
1029   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
1030
1031   sw = gtk_scrolled_window_new (NULL, NULL);
1032   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
1033                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1034
1035   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), vbox);
1036
1037   g_free (specs);
1038
1039   return sw;
1040 }
1041
1042 static GtkWidget *
1043 child_properties_from_object (GObject *object)
1044 {
1045   GtkWidget *prop_edit;
1046   GtkWidget *label;
1047   GtkWidget *sw;
1048   GtkWidget *vbox;
1049   GtkWidget *table;
1050   GtkWidget *parent;
1051   GParamSpec **specs;
1052   guint n_specs;
1053   gint i;
1054
1055   if (!GTK_IS_WIDGET (object))
1056     return NULL;
1057
1058   parent = gtk_widget_get_parent (GTK_WIDGET (object));
1059
1060   if (!parent)
1061     return NULL;
1062
1063   specs = gtk_container_class_list_child_properties (G_OBJECT_GET_CLASS (parent), &n_specs);
1064
1065   table = gtk_table_new (n_specs, 2, FALSE);
1066   gtk_table_set_col_spacing (GTK_TABLE (table), 0, 10);
1067   gtk_table_set_row_spacings (GTK_TABLE (table), 3);
1068
1069   i = 0;
1070   while (i < n_specs)
1071     {
1072       GParamSpec *spec = specs[i];
1073       gboolean can_modify;
1074
1075       prop_edit = NULL;
1076
1077       can_modify = ((spec->flags & G_PARAM_WRITABLE) != 0 &&
1078                     (spec->flags & G_PARAM_CONSTRUCT_ONLY) == 0);
1079
1080       if ((spec->flags & G_PARAM_READABLE) == 0)
1081         {
1082           /* can't display unreadable properties */
1083           ++i;
1084           continue;
1085         }
1086
1087       label = gtk_label_new (g_param_spec_get_nick (spec));
1088       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1089       gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, i, i + 1);
1090
1091       mark_child_property (spec);
1092       prop_edit = property_widget (object, spec, can_modify);
1093       gtk_table_attach_defaults (GTK_TABLE (table), prop_edit, 1, 2, i, i + 1);
1094
1095       if (prop_edit)
1096         {
1097           if (!can_modify)
1098             gtk_widget_set_sensitive (prop_edit, FALSE);
1099
1100           if (g_param_spec_get_blurb (spec))
1101             gtk_widget_set_tooltip_text (prop_edit, g_param_spec_get_blurb (spec));
1102
1103           /* set initial value */
1104           gtk_widget_child_notify (GTK_WIDGET (object), spec->name);
1105         }
1106
1107       ++i;
1108     }
1109
1110   vbox = gtk_vbox_new (FALSE, 0);
1111   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
1112
1113   sw = gtk_scrolled_window_new (NULL, NULL);
1114   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
1115                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1116
1117   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), vbox);
1118
1119   g_free (specs);
1120
1121   return sw;
1122 }
1123
1124 static void
1125 child_properties (GtkWidget *button,
1126                   GObject   *object)
1127 {
1128   create_prop_editor (object, 0);
1129 }
1130
1131 static GtkWidget *
1132 children_from_object (GObject *object)
1133 {
1134   GList *children, *c;
1135   GtkWidget *table, *label, *prop_edit, *button, *vbox, *sw;
1136   gchar *str;
1137   gint i;
1138
1139   if (!GTK_IS_CONTAINER (object))
1140     return NULL;
1141
1142   children = gtk_container_get_children (GTK_CONTAINER (object));
1143
1144   table = gtk_table_new (g_list_length (children), 2, FALSE);
1145   gtk_table_set_col_spacing (GTK_TABLE (table), 0, 10);
1146   gtk_table_set_row_spacings (GTK_TABLE (table), 3);
1147
1148   for (c = children, i = 0; c; c = c->next, i++)
1149     {
1150       object = c->data;
1151
1152       label = gtk_label_new ("Child");
1153       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1154       gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, i, i + 1);
1155
1156       prop_edit = gtk_hbox_new (FALSE, 5);
1157
1158       str = object_label (object, NULL);
1159       label = gtk_label_new (str);
1160       g_free (str);
1161       button = gtk_button_new_with_label ("Properties");
1162       g_signal_connect (button, "clicked",
1163                         G_CALLBACK (child_properties),
1164                         object);
1165
1166       gtk_container_add (GTK_CONTAINER (prop_edit), label);
1167       gtk_container_add (GTK_CONTAINER (prop_edit), button);
1168
1169       gtk_table_attach_defaults (GTK_TABLE (table), prop_edit, 1, 2, i, i + 1);
1170     }
1171
1172   vbox = gtk_vbox_new (FALSE, 0);
1173   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
1174
1175   sw = gtk_scrolled_window_new (NULL, NULL);
1176   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
1177                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1178
1179   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), vbox);
1180
1181   g_list_free (children);
1182
1183   return sw;
1184 }
1185
1186 static GtkWidget *
1187 cells_from_object (GObject *object)
1188 {
1189   GList *cells, *c;
1190   GtkWidget *table, *label, *prop_edit, *button, *vbox, *sw;
1191   gchar *str;
1192   gint i;
1193
1194   if (!GTK_IS_CELL_LAYOUT (object))
1195     return NULL;
1196
1197   cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (object));
1198
1199   table = gtk_table_new (g_list_length (cells), 2, FALSE);
1200   gtk_table_set_col_spacing (GTK_TABLE (table), 0, 10);
1201   gtk_table_set_row_spacings (GTK_TABLE (table), 3);
1202
1203   for (c = cells, i = 0; c; c = c->next, i++)
1204     {
1205       object = c->data;
1206
1207       label = gtk_label_new ("Cell");
1208       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1209       gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, i, i + 1);
1210
1211       prop_edit = gtk_hbox_new (FALSE, 5);
1212
1213       str = object_label (object, NULL);
1214       label = gtk_label_new (str);
1215       g_free (str);
1216       button = gtk_button_new_with_label ("Properties");
1217       g_signal_connect (button, "clicked",
1218                         G_CALLBACK (child_properties),
1219                         object);
1220
1221       gtk_container_add (GTK_CONTAINER (prop_edit), label);
1222       gtk_container_add (GTK_CONTAINER (prop_edit), button);
1223
1224       gtk_table_attach_defaults (GTK_TABLE (table), prop_edit, 1, 2, i, i + 1);
1225     }
1226
1227   vbox = gtk_vbox_new (FALSE, 0);
1228   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
1229
1230   sw = gtk_scrolled_window_new (NULL, NULL);
1231   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
1232                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1233
1234   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), vbox);
1235
1236   g_list_free (cells);
1237
1238   return sw;
1239 }
1240
1241 /* Pass zero for type if you want all properties */
1242 GtkWidget*
1243 create_prop_editor (GObject   *object,
1244                     GType      type)
1245 {
1246   GtkWidget *win;
1247   GtkWidget *notebook;
1248   GtkWidget *properties;
1249   GtkWidget *label;
1250   gchar *title;
1251   GType *ifaces;
1252   guint n_ifaces;
1253
1254   if ((win = g_object_get_data (G_OBJECT (object), "prop-editor-win")))
1255     {
1256       gtk_window_present (GTK_WINDOW (win));
1257       return win;
1258     }
1259
1260   win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1261   if (GTK_IS_WIDGET (object))
1262     gtk_window_set_screen (GTK_WINDOW (win),
1263                            gtk_widget_get_screen (GTK_WIDGET (object)));
1264
1265   /* hold a weak ref to the object we're editing */
1266   g_object_set_data_full (G_OBJECT (object), "prop-editor-win", win, model_destroy);
1267   g_object_set_data_full (G_OBJECT (win), "model-object", object, window_destroy);
1268
1269   if (type == 0)
1270     {
1271       notebook = gtk_notebook_new ();
1272       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_LEFT);
1273
1274       gtk_container_add (GTK_CONTAINER (win), notebook);
1275
1276       type = G_TYPE_FROM_INSTANCE (object);
1277
1278       title = g_strdup_printf ("Properties of %s widget", g_type_name (type));
1279       gtk_window_set_title (GTK_WINDOW (win), title);
1280       g_free (title);
1281
1282       while (type)
1283         {
1284           properties = properties_from_type (object, type);
1285           if (properties)
1286             {
1287               label = gtk_label_new (g_type_name (type));
1288               gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
1289                                         properties, label);
1290             }
1291
1292           type = g_type_parent (type);
1293         }
1294
1295       ifaces = g_type_interfaces (G_TYPE_FROM_INSTANCE (object), &n_ifaces);
1296       while (n_ifaces--)
1297         {
1298           properties = properties_from_type (object, ifaces[n_ifaces]);
1299           if (properties)
1300             {
1301               label = gtk_label_new (g_type_name (ifaces[n_ifaces]));
1302               gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
1303                                         properties, label);
1304             }
1305         }
1306
1307       g_free (ifaces);
1308
1309       properties = child_properties_from_object (object);
1310       if (properties)
1311         {
1312           label = gtk_label_new ("Child properties");
1313           gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
1314                                     properties, label);
1315         }
1316
1317       properties = children_from_object (object);
1318       if (properties)
1319         {
1320           label = gtk_label_new ("Children");
1321           gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
1322                                     properties, label);
1323         }
1324
1325       properties = cells_from_object (object);
1326       if (properties)
1327         {
1328           label = gtk_label_new ("Cell renderers");
1329           gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
1330                                     properties, label);
1331         }
1332     }
1333   else
1334     {
1335       properties = properties_from_type (object, type);
1336       gtk_container_add (GTK_CONTAINER (win), properties);
1337       title = g_strdup_printf ("Properties of %s", g_type_name (type));
1338       gtk_window_set_title (GTK_WINDOW (win), title);
1339       g_free (title);
1340     }
1341
1342   gtk_window_set_default_size (GTK_WINDOW (win), -1, 400);
1343
1344   gtk_widget_show_all (win);
1345
1346   return win;
1347 }
1348