gtkdoc-scangobj.in

   1 #!@PERL@ -w
   2 # -*- cperl -*-
   3 #
   4 # gtk-doc - GTK DocBook documentation generator.
   5 # Copyright (C) 1998  Damon Chaplin
   6 #
   7 # This program is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 2 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program; if not, write to the Free Software
  19 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20 #
  21
  22 #
  23 # This gets information about object heirarchies and signals
  24 # by compiling a small C program. CFLAGS and LDFLAGS must be
  25 # set appropriately before running this script.
  26 #
  27 # NOTE: the lookup_signal_arg_names() function contains the argument names of
  28 #       standard GTK signal handlers. This may need to be updated for new
  29 #       GTK signals or Gnome widget signals.
  30 #       FIXME: this is only needed for undocumented signals, we should remove
  31 #       the list as its totally undermaintained anyway
  32
  33 use Getopt::Long;
  34
  35 push @INC, '@PACKAGE_DATA_DIR@';
  36 require "gtkdoc-common.pl";
  37
  38 # Options
  39
  40 # name of documentation module
  41 my $MODULE;
  42 my $OUTPUT_DIR;
  43 my $PRINT_VERSION;
  44 my $PRINT_HELP;
  45 my $TYPE_INIT_FUNC="g_type_init(); g_type_class_ref(G_TYPE_OBJECT)";
  46 my $QUERY_CHILD_PROPERTIES;
  47
  48 # --nogtkinit is deprecated, as it is the default now anyway.
  49 %optctl = (module => \$MODULE,
  50            types => \$TYPES_FILE,
  51            nogtkinit => \$NO_GTK_INIT,
  52            'type-init-func' => \$TYPE_INIT_FUNC,
  53            'query-child-properties' => \$QUERY_CHILD_PROPERTIES,
  54            'output-dir' => \$OUTPUT_DIR,
  55            'version' => \$PRINT_VERSION,
  56            'help' => \$PRINT_HELP);
  57
  58 GetOptions(\%optctl, "module=s", "types:s", "output-dir:s", "nogtkinit", "type-init-func:s", "query-child-properties:s", "version", "help");
  59
  60 if ($NO_GTK_INIT) {
  61   # Do nothing. This just avoids a warning.
  62   # the option is not used anymore
  63 }
  64
  65 if ($PRINT_VERSION) {
  66     print "@VERSION@\n";
  67     exit 0;
  68 }
  69
  70 if (!$MODULE) {
  71     $PRINT_HELP = 1;
  72 }
  73
  74 if ($PRINT_HELP) {
  75     print <<EOF;
  76 gtkdoc-scangobj version @VERSION@ - introspect g-objects
  77
  78 --module=MODULE_NAME          Name of the doc module being parsed
  79 --types=FILE                  The name of the file to store the types in
  80 --type-init-func=FUNC         The init function to call instead of g_type_init()
  81 --query-child-properties=FUNC A function that returns a list of child
  82                               properties for a class
  83 --output-dir=DIRNAME          The directory where the results are stored
  84 --version                     Print the version of this program
  85 --help                        Print this help
  86 EOF
  87     exit 0;
  88 }
  89
  90 $OUTPUT_DIR = $OUTPUT_DIR ? $OUTPUT_DIR : ".";
  91
  92 $TYPES_FILE = $TYPES_FILE ? $TYPES_FILE : "$OUTPUT_DIR/$MODULE.types";
  93
  94 open (TYPES, $TYPES_FILE) || die "Cannot open $TYPES_FILE: $!\n";
  95 open (OUTPUT, ">$MODULE-scan.c") || die "Cannot open $MODULE-scan.c: $!\n";
  96
  97 my $old_signals_filename = "$OUTPUT_DIR/$MODULE.signals";
  98 my $new_signals_filename = "$OUTPUT_DIR/$MODULE.signals.new";
  99 my $old_hierarchy_filename = "$OUTPUT_DIR/$MODULE.hierarchy";
 100 my $new_hierarchy_filename = "$OUTPUT_DIR/$MODULE.hierarchy.new";
 101 my $old_interfaces_filename = "$OUTPUT_DIR/$MODULE.interfaces";
 102 my $new_interfaces_filename = "$OUTPUT_DIR/$MODULE.interfaces.new";
 103 my $old_prerequisites_filename = "$OUTPUT_DIR/$MODULE.prerequisites";
 104 my $new_prerequisites_filename = "$OUTPUT_DIR/$MODULE.prerequisites.new";
 105 my $old_args_filename = "$OUTPUT_DIR/$MODULE.args";
 106 my $new_args_filename = "$OUTPUT_DIR/$MODULE.args.new";
 107
 108 # write a C program to scan the types
 109
 110 $includes = "";
 111 @types = ();
 112
 113 for (<TYPES>) {
 114     if (/^#include/) {
 115         $includes .= $_;
 116     } elsif (/^gnome_keyring_item_info_get_type$/) {
 117         # HACK: This isn't really a GObject type so skip it.
 118         next;
 119     } elsif (/^%/) {
 120         next;
 121     } elsif (/^\s*$/) {
 122         next;
 123     } else {
 124         chomp;
 125         push @types, $_;
 126     }
 127 }
 128
 129 $ntypes = @types + 1;
 130
 131 print OUTPUT <<EOT;
 132 #include <string.h>
 133 #include <stdlib.h>
 134 #include <stdio.h>
 135 #include <errno.h>
 136 #include <glib-object.h>
 137
 138 EOT
 139
 140 if ($includes) {
 141     print OUTPUT $includes;
 142 } else {
 143     for (@types) {
 144         print OUTPUT "extern GType $_ (void);\n";
 145     }
 146 }
 147
 148 if ($QUERY_CHILD_PROPERTIES) {
 149   print OUTPUT <<EOT;
 150 extern GParamSpec** $QUERY_CHILD_PROPERTIES (gpointer class, guint *n_properties);
 151 EOT
 152 }
 153
 154 print OUTPUT <<EOT;
 155
 156 #ifdef GTK_IS_WIDGET_CLASS
 157 #include <gtk/gtk.h>
 158 #endif
 159 GType object_types[$ntypes];
 160
 161 static GType *
 162 get_object_types (void)
 163 {
 164     gpointer g_object_class;
 165     gint i = 0;
 166 EOT
 167
 168 for (@types) {
 169     print OUTPUT "    object_types[i++] = $_ ();\n";
 170 }
 171
 172 print OUTPUT <<EOT;
 173     object_types[i] = 0;
 174
 175     /* reference the GObjectClass to initialize the param spec pool
 176      * potentially needed by interfaces. See http://bugs.gnome.org/571820 */
 177     g_object_class = g_type_class_ref (G_TYPE_OBJECT);
 178
 179     /* Need to make sure all the types are loaded in and initialize
 180      * their signals and properties.
 181      */
 182     for (i=0; object_types[i]; i++)
 183       {
 184         if (G_TYPE_IS_CLASSED (object_types[i]))
 185           g_type_class_ref (object_types[i]);
 186         if (G_TYPE_IS_INTERFACE (object_types[i]))
 187           g_type_default_interface_ref (object_types[i]);
 188       }
 189
 190     g_type_class_unref (g_object_class);
 191
 192     return object_types;
 193 }
 194
 195 /*
 196  * This uses GObject type functions to output signal prototypes and the object
 197  * hierarchy.
 198  */
 199
 200 /* The output files */
 201 const gchar *signals_filename = "$new_signals_filename";
 202 const gchar *hierarchy_filename = "$new_hierarchy_filename";
 203 const gchar *interfaces_filename = "$new_interfaces_filename";
 204 const gchar *prerequisites_filename = "$new_prerequisites_filename";
 205 const gchar *args_filename = "$new_args_filename";
 206
 207
 208 static void output_signals (void);
 209 static void output_object_signals (FILE *fp,
 210                                    GType object_type);
 211 static void output_object_signal (FILE *fp,
 212                                   const gchar *object_class_name,
 213                                   guint signal_id);
 214 static const gchar * get_type_name (GType type,
 215                                     gboolean * is_pointer);
 216 static const gchar * get_gdk_event (const gchar * signal_name);
 217 static const gchar ** lookup_signal_arg_names (const gchar * type,
 218                                                const gchar * signal_name);
 219
 220 static void output_object_hierarchy (void);
 221 static void output_hierarchy (FILE *fp,
 222                               GType type,
 223                               guint level);
 224
 225 static void output_object_interfaces (void);
 226 static void output_interfaces (FILE *fp,
 227                                GType type);
 228
 229 static void output_interface_prerequisites (void);
 230 static void output_prerequisites (FILE *fp,
 231                                   GType type);
 232
 233 static void output_args (void);
 234 static void output_object_args (FILE *fp, GType object_type);
 235
 236 int
 237 main (int argc, char *argv[])
 238 {
 239   $TYPE_INIT_FUNC;
 240
 241   get_object_types ();
 242
 243   output_signals ();
 244   output_object_hierarchy ();
 245   output_object_interfaces ();
 246   output_interface_prerequisites ();
 247   output_args ();
 248
 249   return 0;
 250 }
 251
 252
 253 static void
 254 output_signals (void)
 255 {
 256   FILE *fp;
 257   gint i;
 258
 259   fp = fopen (signals_filename, "w");
 260   if (fp == NULL)
 261     {
 262       g_warning ("Couldn't open output file: %s : %s", signals_filename, g_strerror(errno));
 263       return;
 264     }
 265
 266   for (i = 0; object_types[i]; i++)
 267     output_object_signals (fp, object_types[i]);
 268
 269   fclose (fp);
 270 }
 271
 272 static gint
 273 compare_signals (const void *a, const void *b)
 274 {
 275   const guint *signal_a = a;
 276   const guint *signal_b = b;
 277
 278   return strcmp (g_signal_name (*signal_a), g_signal_name (*signal_b));
 279 }
 280
 281 /* This outputs all the signals of one object. */
 282 static void
 283 output_object_signals (FILE *fp, GType object_type)
 284 {
 285   const gchar *object_class_name;
 286   guint *signals, n_signals;
 287   guint sig;
 288
 289   if (G_TYPE_IS_INSTANTIATABLE (object_type) ||
 290       G_TYPE_IS_INTERFACE (object_type))
 291     {
 292
 293       object_class_name = g_type_name (object_type);
 294
 295       signals = g_signal_list_ids (object_type, &n_signals);
 296       qsort (signals, n_signals, sizeof (guint), compare_signals);
 297
 298       for (sig = 0; sig < n_signals; sig++)
 299         {
 300            output_object_signal (fp, object_class_name, signals[sig]);
 301         }
 302       g_free (signals);
 303    }
 304 }
 305
 306
 307 /* This outputs one signal. */
 308 static void
 309 output_object_signal (FILE *fp,
 310                       const gchar *object_name,
 311                       guint signal_id)
 312 {
 313   GSignalQuery query_info;
 314   const gchar *type_name, *ret_type, *object_arg, *arg_name;
 315   gchar *pos, *object_arg_lower;
 316   gboolean is_pointer;
 317   gchar buffer[1024];
 318   guint i, param;
 319   const gchar **arg_names;
 320   gint param_num, widget_num, event_num, callback_num;
 321   gint *arg_num;
 322   gchar signal_name[128];
 323   gchar flags[16];
 324
 325   /*  g_print ("Object: %s Signal: %u\\n", object_name, signal_id);*/
 326
 327   param_num = 1;
 328   widget_num = event_num = callback_num = 0;
 329
 330   g_signal_query (signal_id, &query_info);
 331
 332   /* Output the signal object type and the argument name. We assume the
 333      type is a pointer - I think that is OK. We remove "Gtk" or "Gnome" and
 334      convert to lower case for the argument name. */
 335   pos = buffer;
 336   sprintf (pos, "%s ", object_name);
 337   pos += strlen (pos);
 338
 339   /* Try to come up with a sensible variable name for the first arg
 340    * I chops off 2 know prefixes :/ and makes the name lowercase
 341    * It should replace lowercase -> uppercase with '_'
 342    * GFileMonitor -> file_monitor
 343    * GIOExtensionPoint -> extension_point
 344    * GtkTreeView -> tree_view
 345    * if 2nd char is upper case too
 346    *   search for first lower case and go back one char
 347    * else
 348    *   search for next upper case
 349    */
 350   if (!strncmp (object_name, "Gtk", 3))
 351       object_arg = object_name + 3;
 352   else if (!strncmp (object_name, "Gnome", 5))
 353       object_arg = object_name + 5;
 354   else
 355       object_arg = object_name;
 356
 357   object_arg_lower = g_ascii_strdown (object_arg, -1);
 358   sprintf (pos, "*%s\\n", object_arg_lower);
 359   pos += strlen (pos);
 360   if (!strncmp (object_arg_lower, "widget", 6))
 361     widget_num = 2;
 362   g_free(object_arg_lower);
 363
 364   /* Convert signal name to use underscores rather than dashes '-'. */
 365   strncpy (signal_name, query_info.signal_name, 127);
 366   signal_name[127] = '\\0';
 367   for (i = 0; signal_name[i]; i++)
 368     {
 369       if (signal_name[i] == '-')
 370         signal_name[i] = '_';
 371     }
 372
 373   /* Output the signal parameters. */
 374   arg_names = lookup_signal_arg_names (object_name, signal_name);
 375
 376   for (param = 0; param < query_info.n_params; param++)
 377     {
 378       if (arg_names)
 379         {
 380           sprintf (pos, "%s\\n", arg_names[param]);
 381           pos += strlen (pos);
 382         }
 383       else
 384         {
 385           type_name = get_type_name (query_info.param_types[param] & ~G_SIGNAL_TYPE_STATIC_SCOPE, &is_pointer);
 386
 387           /* Most arguments to the callback are called "arg1", "arg2", etc.
 388              GdkWidgets are called "widget", "widget2", ...
 389              GdkEvents are called "event", "event2", ...
 390              GtkCallbacks are called "callback", "callback2", ... */
 391           if (!strcmp (type_name, "GtkWidget"))
 392             {
 393               arg_name = "widget";
 394               arg_num = &widget_num;
 395             }
 396           else if (!strcmp (type_name, "GdkEvent"))
 397             {
 398               type_name = get_gdk_event (signal_name);
 399               arg_name = "event";
 400               arg_num = &event_num;
 401               is_pointer = TRUE;
 402             }
 403           else if (!strcmp (type_name, "GtkCallback")
 404                    || !strcmp (type_name, "GtkCCallback"))
 405             {
 406               arg_name = "callback";
 407               arg_num = &callback_num;
 408             }
 409           else
 410             {
 411               arg_name = "arg";
 412               arg_num = &param_num;
 413             }
 414           sprintf (pos, "%s ", type_name);
 415           pos += strlen (pos);
 416
 417           if (!arg_num || *arg_num == 0)
 418             sprintf (pos, "%s%s\\n", is_pointer ? "*" : " ", arg_name);
 419           else
 420             sprintf (pos, "%s%s%i\\n", is_pointer ? "*" : " ", arg_name,
 421                      *arg_num);
 422           pos += strlen (pos);
 423
 424           if (arg_num)
 425             {
 426               if (*arg_num == 0)
 427                 *arg_num = 2;
 428               else
 429                 *arg_num += 1;
 430             }
 431         }
 432     }
 433
 434   pos = flags;
 435   /* We use one-character flags for simplicity. */
 436   if (query_info.signal_flags & G_SIGNAL_RUN_FIRST)
 437     *pos++ = 'f';
 438   if (query_info.signal_flags & G_SIGNAL_RUN_LAST)
 439     *pos++ = 'l';
 440   if (query_info.signal_flags & G_SIGNAL_RUN_CLEANUP)
 441     *pos++ = 'c';
 442   if (query_info.signal_flags & G_SIGNAL_NO_RECURSE)
 443     *pos++ = 'r';
 444   if (query_info.signal_flags & G_SIGNAL_DETAILED)
 445     *pos++ = 'd';
 446   if (query_info.signal_flags & G_SIGNAL_ACTION)
 447     *pos++ = 'a';
 448   if (query_info.signal_flags & G_SIGNAL_NO_HOOKS)
 449     *pos++ = 'h';
 450   *pos = 0;
 451
 452   /* Output the return type and function name. */
 453   ret_type = get_type_name (query_info.return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE, &is_pointer);
 454
 455   fprintf (fp,
 456            "<SIGNAL>\\n<NAME>%s::%s</NAME>\\n<RETURNS>%s%s</RETURNS>\\n<FLAGS>%s</FLAGS>\\n%s</SIGNAL>\\n\\n",
 457            object_name, query_info.signal_name, ret_type, is_pointer ? "*" : "", flags, buffer);
 458 }
 459
 460
 461 /* Returns the type name to use for a signal argument or return value, given
 462    the GtkType from the signal info. It also sets is_pointer to TRUE if the
 463    argument needs a '*' since it is a pointer. */
 464 static const gchar *
 465 get_type_name (GType type, gboolean * is_pointer)
 466 {
 467   const gchar *type_name;
 468
 469   *is_pointer = FALSE;
 470   type_name = g_type_name (type);
 471
 472   switch (type) {
 473   case G_TYPE_NONE:
 474   case G_TYPE_CHAR:
 475   case G_TYPE_UCHAR:
 476   case G_TYPE_BOOLEAN:
 477   case G_TYPE_INT:
 478   case G_TYPE_UINT:
 479   case G_TYPE_LONG:
 480   case G_TYPE_ULONG:
 481   case G_TYPE_FLOAT:
 482   case G_TYPE_DOUBLE:
 483   case G_TYPE_POINTER:
 484     /* These all have normal C type names so they are OK. */
 485     return type_name;
 486
 487   case G_TYPE_STRING:
 488     /* A GtkString is really a gchar*. */
 489     *is_pointer = TRUE;
 490     return "gchar";
 491
 492   case G_TYPE_ENUM:
 493   case G_TYPE_FLAGS:
 494     /* We use a gint for both of these. Hopefully a subtype with a decent
 495        name will be registered and used instead, as GTK+ does itself. */
 496     return "gint";
 497
 498   case G_TYPE_BOXED:
 499     /* The boxed type shouldn't be used itself, only subtypes. Though we
 500        return 'gpointer' just in case. */
 501     return "gpointer";
 502
 503   case G_TYPE_PARAM:
 504     /* A GParam is really a GParamSpec*. */
 505     *is_pointer = TRUE;
 506     return "GParamSpec";
 507
 508   default:
 509     break;
 510   }
 511
 512   /* For all GObject subclasses we can use the class name with a "*",
 513      e.g. 'GtkWidget *'. */
 514   if (g_type_is_a (type, G_TYPE_OBJECT))
 515     *is_pointer = TRUE;
 516
 517   /* Also catch non GObject root types */
 518   if (G_TYPE_IS_CLASSED (type))
 519     *is_pointer = TRUE;
 520
 521   /* All boxed subtypes will be pointers as well. */
 522   if (g_type_is_a (type, G_TYPE_BOXED))
 523     *is_pointer = TRUE;
 524
 525   /* All pointer subtypes will be pointers as well. */
 526   if (g_type_is_a (type, G_TYPE_POINTER))
 527     *is_pointer = TRUE;
 528
 529   /* But enums are not */
 530   if (g_type_is_a (type, G_TYPE_ENUM) ||
 531       g_type_is_a (type, G_TYPE_FLAGS))
 532     *is_pointer = FALSE;
 533
 534   return type_name;
 535 }
 536
 537
 538 static const gchar *
 539 get_gdk_event (const gchar * signal_name)
 540 {
 541   static const gchar *GbGDKEvents[] =
 542   {
 543     "button_press_event", "GdkEventButton",
 544     "button_release_event", "GdkEventButton",
 545     "motion_notify_event", "GdkEventMotion",
 546     "delete_event", "GdkEvent",
 547     "destroy_event", "GdkEvent",
 548     "expose_event", "GdkEventExpose",
 549     "key_press_event", "GdkEventKey",
 550     "key_release_event", "GdkEventKey",
 551     "enter_notify_event", "GdkEventCrossing",
 552     "leave_notify_event", "GdkEventCrossing",
 553     "configure_event", "GdkEventConfigure",
 554     "focus_in_event", "GdkEventFocus",
 555     "focus_out_event", "GdkEventFocus",
 556     "map_event", "GdkEvent",
 557     "unmap_event", "GdkEvent",
 558     "property_notify_event", "GdkEventProperty",
 559     "selection_clear_event", "GdkEventSelection",
 560     "selection_request_event", "GdkEventSelection",
 561     "selection_notify_event", "GdkEventSelection",
 562     "proximity_in_event", "GdkEventProximity",
 563     "proximity_out_event", "GdkEventProximity",
 564     "drag_begin_event", "GdkEventDragBegin",
 565     "drag_request_event", "GdkEventDragRequest",
 566     "drag_end_event", "GdkEventDragRequest",
 567     "drop_enter_event", "GdkEventDropEnter",
 568     "drop_leave_event", "GdkEventDropLeave",
 569     "drop_data_available_event", "GdkEventDropDataAvailable",
 570     "other_event", "GdkEventOther",
 571     "client_event", "GdkEventClient",
 572     "no_expose_event", "GdkEventNoExpose",
 573     "visibility_notify_event", "GdkEventVisibility",
 574     "window_state_event", "GdkEventWindowState",
 575     "scroll_event", "GdkEventScroll",
 576     NULL
 577   };
 578
 579   gint i;
 580
 581   for (i = 0; GbGDKEvents[i]; i += 2)
 582     {
 583       if (!strcmp (signal_name, GbGDKEvents[i]))
 584         return GbGDKEvents[i + 1];
 585     }
 586   return "GdkEvent";
 587 }
 588
 589
 590 /* This returns argument names to use for some known GTK signals.
 591     It is passed a widget name, e.g. 'GtkCList' and a signal name, e.g.
 592     'select_row' and it returns a pointer to an array of argument types and
 593     names. */
 594 static const gchar **
 595 lookup_signal_arg_names (const gchar * type, const gchar * signal_name)
 596 {
 597   /* Each arg array starts with the object type name and the signal name,
 598      and then signal arguments follow. */
 599   static const gchar *GbArgTable[][16] =
 600   {
 601     {"GtkCList", "select_row",
 602      "gint             row",
 603      "gint             column",
 604      "GdkEventButton  *event"},
 605     {"GtkCList", "unselect_row",
 606      "gint             row",
 607      "gint             column",
 608      "GdkEventButton  *event"},
 609     {"GtkCList", "click_column",
 610      "gint             column"},
 611
 612     {"GtkCList", "resize_column",
 613      "gint             column",
 614      "gint             width"},
 615
 616     {"GtkCList", "extend_selection",
 617      "GtkScrollType    scroll_type",
 618      "gfloat           position",
 619      "gboolean         auto_start_selection"},
 620     {"GtkCList", "scroll_vertical",
 621      "GtkScrollType    scroll_type",
 622      "gfloat           position"},
 623     {"GtkCList", "scroll_horizontal",
 624      "GtkScrollType    scroll_type",
 625      "gfloat           position"},
 626
 627     {"GtkCTree", "tree_select_row",
 628      "GtkCTreeNode    *node",
 629      "gint             column"},
 630     {"GtkCTree", "tree_unselect_row",
 631      "GtkCTreeNode    *node",
 632      "gint             column"},
 633     {"GtkCTree", "tree_expand",
 634      "GtkCTreeNode    *node"},
 635     {"GtkCTree", "tree_collapse",
 636      "GtkCTreeNode    *node"},
 637     {"GtkCTree", "tree_move",
 638      "GtkCTreeNode    *node",
 639      "GtkCTreeNode    *new_parent",
 640      "GtkCTreeNode    *new_sibling"},
 641     {"GtkCTree", "change_focus_row_expansion",
 642      "GtkCTreeExpansionType expansion"},
 643
 644     {"GtkEditable", "insert_text",
 645      "gchar           *new_text",
 646      "gint             new_text_length",
 647      "gint            *position"},
 648     {"GtkEditable", "delete_text",
 649      "gint             start_pos",
 650      "gint             end_pos"},
 651     {"GtkEditable", "set_editable",
 652      "gboolean         is_editable"},
 653     {"GtkEditable", "move_cursor",
 654      "gint             x",
 655      "gint             y"},
 656     {"GtkEditable", "move_word",
 657      "gint             num_words"},
 658     {"GtkEditable", "move_page",
 659      "gint             x",
 660      "gint             y"},
 661     {"GtkEditable", "move_to_row",
 662      "gint             row"},
 663     {"GtkEditable", "move_to_column",
 664      "gint             column"},
 665
 666     {"GtkEditable", "kill_char",
 667      "gint             direction"},
 668     {"GtkEditable", "kill_word",
 669      "gint             direction"},
 670     {"GtkEditable", "kill_line",
 671      "gint             direction"},
 672
 673
 674     {"GtkInputDialog", "enable_device",
 675      "GdkDevice       *deviceid"},
 676     {"GtkInputDialog", "disable_device",
 677      "GdkDevice       *deviceid"},
 678
 679     {"GtkListItem", "extend_selection",
 680      "GtkScrollType    scroll_type",
 681      "gfloat           position",
 682      "gboolean         auto_start_selection"},
 683     {"GtkListItem", "scroll_vertical",
 684      "GtkScrollType    scroll_type",
 685      "gfloat           position"},
 686     {"GtkListItem", "scroll_horizontal",
 687      "GtkScrollType    scroll_type",
 688      "gfloat           position"},
 689
 690     {"GtkMenuShell", "move_current",
 691      "GtkMenuDirectionType direction"},
 692     {"GtkMenuShell", "activate_current",
 693      "gboolean         force_hide"},
 694
 695
 696     {"GtkNotebook", "switch_page",
 697      "GtkNotebookPage *page",
 698      "guint            page_num"},
 699     {"GtkStatusbar", "text_pushed",
 700      "guint            context_id",
 701      "gchar           *text"},
 702     {"GtkStatusbar", "text_popped",
 703      "guint            context_id",
 704      "gchar           *text"},
 705     {"GtkTipsQuery", "widget_entered",
 706      "GtkWidget       *widget",
 707      "gchar           *tip_text",
 708      "gchar           *tip_private"},
 709     {"GtkTipsQuery", "widget_selected",
 710      "GtkWidget       *widget",
 711      "gchar           *tip_text",
 712      "gchar           *tip_private",
 713      "GdkEventButton  *event"},
 714     {"GtkToolbar", "orientation_changed",
 715      "GtkOrientation   orientation"},
 716     {"GtkToolbar", "style_changed",
 717      "GtkToolbarStyle  style"},
 718     {"GtkWidget", "draw",
 719      "GdkRectangle    *area"},
 720     {"GtkWidget", "size_request",
 721      "GtkRequisition  *requisition"},
 722     {"GtkWidget", "size_allocate",
 723      "GtkAllocation   *allocation"},
 724     {"GtkWidget", "state_changed",
 725      "GtkStateType     state"},
 726     {"GtkWidget", "style_set",
 727      "GtkStyle        *previous_style"},
 728
 729     {"GtkWidget", "install_accelerator",
 730      "gchar           *signal_name",
 731      "gchar            key",
 732      "gint             modifiers"},
 733
 734     {"GtkWidget", "add_accelerator",
 735      "guint            accel_signal_id",
 736      "GtkAccelGroup   *accel_group",
 737      "guint            accel_key",
 738      "GdkModifierType  accel_mods",
 739      "GtkAccelFlags    accel_flags"},
 740
 741     {"GtkWidget", "parent_set",
 742      "GtkObject       *old_parent"},
 743
 744     {"GtkWidget", "remove_accelerator",
 745      "GtkAccelGroup   *accel_group",
 746      "guint            accel_key",
 747      "GdkModifierType  accel_mods"},
 748     {"GtkWidget", "debug_msg",
 749      "gchar           *message"},
 750     {"GtkWindow", "move_resize",
 751      "gint            *x",
 752      "gint            *y",
 753      "gint             width",
 754      "gint             height"},
 755     {"GtkWindow", "set_focus",
 756      "GtkWidget       *widget"},
 757
 758     {"GtkWidget", "selection_get",
 759      "GtkSelectionData *data",
 760      "guint            info",
 761      "guint            time"},
 762     {"GtkWidget", "selection_received",
 763      "GtkSelectionData *data",
 764      "guint            time"},
 765
 766     {"GtkWidget", "drag_begin",
 767      "GdkDragContext  *drag_context"},
 768     {"GtkWidget", "drag_end",
 769      "GdkDragContext  *drag_context"},
 770     {"GtkWidget", "drag_data_delete",
 771      "GdkDragContext  *drag_context"},
 772     {"GtkWidget", "drag_leave",
 773      "GdkDragContext  *drag_context",
 774      "guint            time"},
 775     {"GtkWidget", "drag_motion",
 776      "GdkDragContext  *drag_context",
 777      "gint             x",
 778      "gint             y",
 779      "guint            time"},
 780     {"GtkWidget", "drag_drop",
 781      "GdkDragContext  *drag_context",
 782      "gint             x",
 783      "gint             y",
 784      "guint            time"},
 785     {"GtkWidget", "drag_data_get",
 786      "GdkDragContext  *drag_context",
 787      "GtkSelectionData *data",
 788      "guint            info",
 789      "guint            time"},
 790     {"GtkWidget", "drag_data_received",
 791      "GdkDragContext  *drag_context",
 792      "gint             x",
 793      "gint             y",
 794      "GtkSelectionData *data",
 795      "guint            info",
 796      "guint            time"},
 797
 798     {NULL}
 799   };
 800
 801   gint i;
 802
 803   for (i = 0; GbArgTable[i][0]; i++)
 804     {
 805 #if 1
 806       if (!strcmp (type, GbArgTable[i][0])
 807           && !strcmp (signal_name, GbArgTable[i][1]))
 808         return &GbArgTable[i][2];
 809 #endif
 810     }
 811   return NULL;
 812 }
 813
 814 /* This outputs the hierarchy of all objects which have been initialized,
 815    i.e. by calling their XXX_get_type() initialization function. */
 816 static void
 817 output_object_hierarchy (void)
 818 {
 819   FILE *fp;
 820   gint i;
 821
 822   fp = fopen (hierarchy_filename, "w");
 823   if (fp == NULL)
 824     {
 825       g_warning ("Couldn't open output file: %s : %s", hierarchy_filename, g_strerror(errno));
 826       return;
 827     }
 828   output_hierarchy (fp, G_TYPE_OBJECT, 0);
 829   output_hierarchy (fp, G_TYPE_INTERFACE, 0);
 830
 831   for (i=0; object_types[i]; i++) {
 832     if (!g_type_parent (object_types[i]) &&
 833       (object_types[i] != G_TYPE_OBJECT) &&
 834       (object_types[i] != G_TYPE_INTERFACE)
 835     ) {
 836       output_hierarchy (fp, object_types[i], 0);
 837     }
 838   }
 839
 840   fclose (fp);
 841 }
 842
 843 /* This is called recursively to output the hierarchy of a widget. */
 844 static void
 845 output_hierarchy (FILE  *fp,
 846                   GType  type,
 847                   guint   level)
 848 {
 849   guint i;
 850   GType *children;
 851   guint n_children;
 852
 853   if (!type)
 854     return;
 855
 856   for (i = 0; i < level; i++)
 857     fprintf (fp, "  ");
 858   fprintf (fp, "%s\\n", g_type_name (type));
 859
 860   children = g_type_children (type, &n_children);
 861
 862   for (i=0; i < n_children; i++)
 863     output_hierarchy (fp, children[i], level + 1);
 864
 865   g_free (children);
 866 }
 867
 868 static void output_object_interfaces (void)
 869 {
 870   guint i;
 871   FILE *fp;
 872
 873   fp = fopen (interfaces_filename, "w");
 874   if (fp == NULL)
 875     {
 876       g_warning ("Couldn't open output file: %s : %s", interfaces_filename, g_strerror(errno));
 877       return;
 878     }
 879   output_interfaces (fp, G_TYPE_OBJECT);
 880
 881   for (i = 0; object_types[i]; i++)
 882     {
 883       if (!g_type_parent (object_types[i]) &&
 884           (object_types[i] != G_TYPE_OBJECT) &&
 885           G_TYPE_IS_INSTANTIATABLE (object_types[i]))
 886         {
 887           output_interfaces (fp, object_types[i]);
 888         }
 889     }
 890   fclose (fp);
 891 }
 892
 893 static void
 894 output_interfaces (FILE  *fp,
 895                    GType  type)
 896 {
 897   guint i;
 898   GType *children, *interfaces;
 899   guint n_children, n_interfaces;
 900
 901   if (!type)
 902     return;
 903
 904   interfaces = g_type_interfaces (type, &n_interfaces);
 905
 906   if (n_interfaces > 0)
 907     {
 908       fprintf (fp, "%s", g_type_name (type));
 909       for (i=0; i < n_interfaces; i++)
 910           fprintf (fp, " %s", g_type_name (interfaces[i]));
 911       fprintf (fp, "\\n");
 912      }
 913   g_free (interfaces);
 914
 915   children = g_type_children (type, &n_children);
 916
 917   for (i=0; i < n_children; i++)
 918     output_interfaces (fp, children[i]);
 919
 920   g_free (children);
 921 }
 922
 923 static void output_interface_prerequisites (void)
 924 {
 925   FILE *fp;
 926
 927   fp = fopen (prerequisites_filename, "w");
 928   if (fp == NULL)
 929     {
 930       g_warning ("Couldn't open output file: %s : %s", prerequisites_filename, g_strerror(errno));
 931       return;
 932     }
 933   output_prerequisites (fp, G_TYPE_INTERFACE);
 934   fclose (fp);
 935 }
 936
 937 static void
 938 output_prerequisites (FILE  *fp,
 939                       GType  type)
 940 {
 941 #if GLIB_CHECK_VERSION(2,1,0)
 942   guint i;
 943   GType *children, *prerequisites;
 944   guint n_children, n_prerequisites;
 945
 946   if (!type)
 947     return;
 948
 949   prerequisites = g_type_interface_prerequisites (type, &n_prerequisites);
 950
 951   if (n_prerequisites > 0)
 952     {
 953       fprintf (fp, "%s", g_type_name (type));
 954       for (i=0; i < n_prerequisites; i++)
 955           fprintf (fp, " %s", g_type_name (prerequisites[i]));
 956       fprintf (fp, "\\n");
 957      }
 958   g_free (prerequisites);
 959
 960   children = g_type_children (type, &n_children);
 961
 962   for (i=0; i < n_children; i++)
 963     output_prerequisites (fp, children[i]);
 964
 965   g_free (children);
 966 #endif
 967 }
 968
 969 static void
 970 output_args (void)
 971 {
 972   FILE *fp;
 973   gint i;
 974
 975   fp = fopen (args_filename, "w");
 976   if (fp == NULL)
 977     {
 978       g_warning ("Couldn't open output file: %s : %s", args_filename, g_strerror(errno));
 979       return;
 980     }
 981
 982   for (i = 0; object_types[i]; i++) {
 983     output_object_args (fp, object_types[i]);
 984   }
 985
 986   fclose (fp);
 987 }
 988
 989 static gint
 990 compare_param_specs (const void *a, const void *b)
 991 {
 992   GParamSpec *spec_a = *(GParamSpec **)a;
 993   GParamSpec *spec_b = *(GParamSpec **)b;
 994
 995   return strcmp (g_param_spec_get_name (spec_a), g_param_spec_get_name (spec_b));
 996 }
 997
 998 /* Its common to have unsigned properties restricted
 999  * to the signed range. Therefore we make this look
1000  * a bit nicer by spelling out the max constants.
1001  */
1002
1003 /* Don't use "==" with floats, it might trigger a gcc warning.  */
1004 #define GTKDOC_COMPARE_FLOAT(x, y) (x <= y && x >= y)
1005
1006 static gchar*
1007 describe_double_constant (gdouble value)
1008 {
1009   gchar *desc;
1010
1011   if (GTKDOC_COMPARE_FLOAT (value, G_MAXDOUBLE))
1012     desc = g_strdup ("G_MAXDOUBLE");
1013   else if (GTKDOC_COMPARE_FLOAT (value, G_MINDOUBLE))
1014     desc = g_strdup ("G_MINDOUBLE");
1015   else if (GTKDOC_COMPARE_FLOAT (value, -G_MAXDOUBLE))
1016     desc = g_strdup ("-G_MAXDOUBLE");
1017   else if (GTKDOC_COMPARE_FLOAT (value, G_MAXFLOAT))
1018     desc = g_strdup ("G_MAXFLOAT");
1019   else if (GTKDOC_COMPARE_FLOAT (value, G_MINFLOAT))
1020     desc = g_strdup ("G_MINFLOAT");
1021   else if (GTKDOC_COMPARE_FLOAT (value, -G_MAXFLOAT))
1022     desc = g_strdup ("-G_MAXFLOAT");
1023   else
1024     desc = g_strdup_printf ("%lg", value);
1025
1026   return desc;
1027 }
1028
1029 static gchar*
1030 describe_signed_constant (gsize size, gint64 value)
1031 {
1032   gchar *desc = NULL;
1033
1034   switch (size) {
1035     case 2:
1036       if (sizeof (int) == 2) {
1037         if (value == G_MAXINT)
1038           desc = g_strdup ("G_MAXINT");
1039         else if (value == G_MININT)
1040           desc = g_strdup ("G_MININT");
1041         else if (value == (gint64)G_MAXUINT)
1042           desc = g_strdup ("G_MAXUINT");
1043       }
1044       break;
1045     case 4:
1046       if (sizeof (int) == 4) {
1047         if (value == G_MAXINT)
1048           desc = g_strdup ("G_MAXINT");
1049         else if (value == G_MININT)
1050           desc = g_strdup ("G_MININT");
1051         else if (value == (gint64)G_MAXUINT)
1052           desc = g_strdup ("G_MAXUINT");
1053       }
1054       if (value == G_MAXLONG)
1055         desc = g_strdup ("G_MAXLONG");
1056       else if (value == G_MINLONG)
1057         desc = g_strdup ("G_MINLONG");
1058       else if (value == (gint64)G_MAXULONG)
1059         desc = g_strdup ("G_MAXULONG");
1060       break;
1061     case 8:
1062       if (value == G_MAXINT64)
1063         desc = g_strdup ("G_MAXINT64");
1064       else if (value == G_MININT64)
1065         desc = g_strdup ("G_MININT64");
1066       break;
1067     default:
1068       break;
1069   }
1070   if (!desc)
1071     desc = g_strdup_printf ("%" G_GINT64_FORMAT, value);
1072
1073   return desc;
1074 }
1075
1076 static gchar*
1077 describe_unsigned_constant (gsize size, guint64 value)
1078 {
1079   gchar *desc = NULL;
1080
1081   switch (size) {
1082     case 2:
1083       if (sizeof (int) == 2) {
1084         if (value == (guint64)G_MAXINT)
1085           desc = g_strdup ("G_MAXINT");
1086         else if (value == G_MAXUINT)
1087           desc = g_strdup ("G_MAXUINT");
1088       }
1089       break;
1090     case 4:
1091       if (sizeof (int) == 4) {
1092         if (value == (guint64)G_MAXINT)
1093           desc = g_strdup ("G_MAXINT");
1094         else if (value == G_MAXUINT)
1095           desc = g_strdup ("G_MAXUINT");
1096       }
1097       if (value == (guint64)G_MAXLONG)
1098         desc = g_strdup ("G_MAXLONG");
1099       else if (value == G_MAXULONG)
1100         desc = g_strdup ("G_MAXULONG");
1101       break;
1102     case 8:
1103       if (value == G_MAXINT64)
1104         desc = g_strdup ("G_MAXINT64");
1105       else if (value == G_MAXUINT64)
1106         desc = g_strdup ("G_MAXUINT64");
1107       break;
1108     default:
1109       break;
1110   }
1111   if (!desc)
1112     desc = g_strdup_printf ("%" G_GUINT64_FORMAT, value);
1113
1114   return desc;
1115 }
1116
1117 static gchar*
1118 describe_type (GParamSpec *spec)
1119 {
1120   gchar *desc;
1121   gchar *lower;
1122   gchar *upper;
1123
1124   if (G_IS_PARAM_SPEC_CHAR (spec))
1125     {
1126       GParamSpecChar *pspec = G_PARAM_SPEC_CHAR (spec);
1127
1128       lower = describe_signed_constant (sizeof(gchar), pspec->minimum);
1129       upper = describe_signed_constant (sizeof(gchar), pspec->maximum);
1130       if (pspec->minimum == G_MININT8 && pspec->maximum == G_MAXINT8)
1131         desc = g_strdup ("");
1132       else if (pspec->minimum == G_MININT8)
1133         desc = g_strdup_printf ("<= %s", upper);
1134       else if (pspec->maximum == G_MAXINT8)
1135         desc = g_strdup_printf (">= %s", lower);
1136       else
1137         desc = g_strdup_printf ("[%s,%s]", lower, upper);
1138       g_free (lower);
1139       g_free (upper);
1140     }
1141   else if (G_IS_PARAM_SPEC_UCHAR (spec))
1142     {
1143       GParamSpecUChar *pspec = G_PARAM_SPEC_UCHAR (spec);
1144
1145       lower = describe_unsigned_constant (sizeof(guchar), pspec->minimum);
1146       upper = describe_unsigned_constant (sizeof(guchar), pspec->maximum);
1147       if (pspec->minimum == 0 && pspec->maximum == G_MAXUINT8)
1148         desc = g_strdup ("");
1149       else if (pspec->minimum == 0)
1150         desc = g_strdup_printf ("<= %s", upper);
1151       else if (pspec->maximum == G_MAXUINT8)
1152         desc = g_strdup_printf (">= %s", lower);
1153       else
1154         desc = g_strdup_printf ("[%s,%s]", lower, upper);
1155       g_free (lower);
1156       g_free (upper);
1157     }
1158   else if (G_IS_PARAM_SPEC_INT (spec))
1159     {
1160       GParamSpecInt *pspec = G_PARAM_SPEC_INT (spec);
1161
1162       lower = describe_signed_constant (sizeof(gint), pspec->minimum);
1163       upper = describe_signed_constant (sizeof(gint), pspec->maximum);
1164       if (pspec->minimum == G_MININT && pspec->maximum == G_MAXINT)
1165         desc = g_strdup ("");
1166       else if (pspec->minimum == G_MININT)
1167         desc = g_strdup_printf ("<= %s", upper);
1168       else if (pspec->maximum == G_MAXINT)
1169         desc = g_strdup_printf (">= %s", lower);
1170       else
1171         desc = g_strdup_printf ("[%s,%s]", lower, upper);
1172       g_free (lower);
1173       g_free (upper);
1174     }
1175   else if (G_IS_PARAM_SPEC_UINT (spec))
1176     {
1177       GParamSpecUInt *pspec = G_PARAM_SPEC_UINT (spec);
1178
1179       lower = describe_unsigned_constant (sizeof(guint), pspec->minimum);
1180       upper = describe_unsigned_constant (sizeof(guint), pspec->maximum);
1181       if (pspec->minimum == 0 && pspec->maximum == G_MAXUINT)
1182         desc = g_strdup ("");
1183       else if (pspec->minimum == 0)
1184         desc = g_strdup_printf ("<= %s", upper);
1185       else if (pspec->maximum == G_MAXUINT)
1186         desc = g_strdup_printf (">= %s", lower);
1187       else
1188         desc = g_strdup_printf ("[%s,%s]", lower, upper);
1189       g_free (lower);
1190       g_free (upper);
1191     }
1192   else if (G_IS_PARAM_SPEC_LONG (spec))
1193     {
1194       GParamSpecLong *pspec = G_PARAM_SPEC_LONG (spec);
1195
1196       lower = describe_signed_constant (sizeof(glong), pspec->minimum);
1197       upper = describe_signed_constant (sizeof(glong), pspec->maximum);
1198       if (pspec->minimum == G_MINLONG && pspec->maximum == G_MAXLONG)
1199         desc = g_strdup ("");
1200       else if (pspec->minimum == G_MINLONG)
1201         desc = g_strdup_printf ("<= %s", upper);
1202       else if (pspec->maximum == G_MAXLONG)
1203         desc = g_strdup_printf (">= %s", lower);
1204       else
1205         desc = g_strdup_printf ("[%s,%s]", lower, upper);
1206       g_free (lower);
1207       g_free (upper);
1208     }
1209   else if (G_IS_PARAM_SPEC_ULONG (spec))
1210     {
1211       GParamSpecULong *pspec = G_PARAM_SPEC_ULONG (spec);
1212
1213       lower = describe_unsigned_constant (sizeof(gulong), pspec->minimum);
1214       upper = describe_unsigned_constant (sizeof(gulong), pspec->maximum);
1215       if (pspec->minimum == 0 && pspec->maximum == G_MAXULONG)
1216         desc = g_strdup ("");
1217       else if (pspec->minimum == 0)
1218         desc = g_strdup_printf ("<= %s", upper);
1219       else if (pspec->maximum == G_MAXULONG)
1220         desc = g_strdup_printf (">= %s", lower);
1221       else
1222         desc = g_strdup_printf ("[%s,%s]", lower, upper);
1223       g_free (lower);
1224       g_free (upper);
1225     }
1226   else if (G_IS_PARAM_SPEC_INT64 (spec))
1227     {
1228       GParamSpecInt64 *pspec = G_PARAM_SPEC_INT64 (spec);
1229
1230       lower = describe_signed_constant (sizeof(gint64), pspec->minimum);
1231       upper = describe_signed_constant (sizeof(gint64), pspec->maximum);
1232       if (pspec->minimum == G_MININT64 && pspec->maximum == G_MAXINT64)
1233         desc = g_strdup ("");
1234       else if (pspec->minimum == G_MININT64)
1235         desc = g_strdup_printf ("<= %s", upper);
1236       else if (pspec->maximum == G_MAXINT64)
1237         desc = g_strdup_printf (">= %s", lower);
1238       else
1239         desc = g_strdup_printf ("[%s,%s]", lower, upper);
1240       g_free (lower);
1241       g_free (upper);
1242     }
1243   else if (G_IS_PARAM_SPEC_UINT64 (spec))
1244     {
1245       GParamSpecUInt64 *pspec = G_PARAM_SPEC_UINT64 (spec);
1246
1247       lower = describe_unsigned_constant (sizeof(guint64), pspec->minimum);
1248       upper = describe_unsigned_constant (sizeof(guint64), pspec->maximum);
1249       if (pspec->minimum == 0 && pspec->maximum == G_MAXUINT64)
1250         desc = g_strdup ("");
1251       else if (pspec->minimum == 0)
1252         desc = g_strdup_printf ("<= %s", upper);
1253       else if (pspec->maximum == G_MAXUINT64)
1254         desc = g_strdup_printf (">= %s", lower);
1255       else
1256         desc = g_strdup_printf ("[%s,%s]", lower, upper);
1257       g_free (lower);
1258       g_free (upper);
1259     }
1260   else if (G_IS_PARAM_SPEC_FLOAT (spec))
1261     {
1262       GParamSpecFloat *pspec = G_PARAM_SPEC_FLOAT (spec);
1263
1264       lower = describe_double_constant (pspec->minimum);
1265       upper = describe_double_constant (pspec->maximum);
1266       if (GTKDOC_COMPARE_FLOAT (pspec->minimum, -G_MAXFLOAT))
1267         {
1268           if (GTKDOC_COMPARE_FLOAT (pspec->maximum, G_MAXFLOAT))
1269             desc = g_strdup ("");
1270           else
1271             desc = g_strdup_printf ("<= %s", upper);
1272         }
1273       else if (GTKDOC_COMPARE_FLOAT (pspec->maximum, G_MAXFLOAT))
1274         desc = g_strdup_printf (">= %s", lower);
1275       else
1276         desc = g_strdup_printf ("[%s,%s]", lower, upper);
1277       g_free (lower);
1278       g_free (upper);
1279     }
1280   else if (G_IS_PARAM_SPEC_DOUBLE (spec))
1281     {
1282       GParamSpecDouble *pspec = G_PARAM_SPEC_DOUBLE (spec);
1283
1284       lower = describe_double_constant (pspec->minimum);
1285       upper = describe_double_constant (pspec->maximum);
1286       if (GTKDOC_COMPARE_FLOAT (pspec->minimum, -G_MAXDOUBLE))
1287         {
1288           if (GTKDOC_COMPARE_FLOAT (pspec->maximum, G_MAXDOUBLE))
1289             desc = g_strdup ("");
1290           else
1291             desc = g_strdup_printf ("<= %s", upper);
1292         }
1293       else if (GTKDOC_COMPARE_FLOAT (pspec->maximum, G_MAXDOUBLE))
1294         desc = g_strdup_printf (">= %s", lower);
1295       else
1296         desc = g_strdup_printf ("[%s,%s]", lower, upper);
1297       g_free (lower);
1298       g_free (upper);
1299     }
1300   else
1301     {
1302       desc = g_strdup ("");
1303     }
1304
1305   return desc;
1306 }
1307
1308 static gchar*
1309 describe_default (GParamSpec *spec)
1310 {
1311   gchar *desc;
1312
1313   if (G_IS_PARAM_SPEC_CHAR (spec))
1314     {
1315       GParamSpecChar *pspec = G_PARAM_SPEC_CHAR (spec);
1316
1317       desc = g_strdup_printf ("%d", pspec->default_value);
1318     }
1319   else if (G_IS_PARAM_SPEC_UCHAR (spec))
1320     {
1321       GParamSpecUChar *pspec = G_PARAM_SPEC_UCHAR (spec);
1322
1323       desc = g_strdup_printf ("%u", pspec->default_value);
1324     }
1325   else if (G_IS_PARAM_SPEC_BOOLEAN (spec))
1326     {
1327       GParamSpecBoolean *pspec = G_PARAM_SPEC_BOOLEAN (spec);
1328
1329       desc = g_strdup_printf ("%s", pspec->default_value ? "TRUE" : "FALSE");
1330     }
1331   else if (G_IS_PARAM_SPEC_INT (spec))
1332     {
1333       GParamSpecInt *pspec = G_PARAM_SPEC_INT (spec);
1334
1335       desc = g_strdup_printf ("%d", pspec->default_value);
1336     }
1337   else if (G_IS_PARAM_SPEC_UINT (spec))
1338     {
1339       GParamSpecUInt *pspec = G_PARAM_SPEC_UINT (spec);
1340
1341       desc = g_strdup_printf ("%u", pspec->default_value);
1342     }
1343   else if (G_IS_PARAM_SPEC_LONG (spec))
1344     {
1345       GParamSpecLong *pspec = G_PARAM_SPEC_LONG (spec);
1346
1347       desc = g_strdup_printf ("%ld", pspec->default_value);
1348     }
1349   else if (G_IS_PARAM_SPEC_LONG (spec))
1350     {
1351       GParamSpecULong *pspec = G_PARAM_SPEC_ULONG (spec);
1352
1353       desc = g_strdup_printf ("%lu", pspec->default_value);
1354     }
1355   else if (G_IS_PARAM_SPEC_INT64 (spec))
1356     {
1357       GParamSpecInt64 *pspec = G_PARAM_SPEC_INT64 (spec);
1358
1359       desc = g_strdup_printf ("%" G_GINT64_FORMAT, pspec->default_value);
1360     }
1361   else if (G_IS_PARAM_SPEC_UINT64 (spec))
1362     {
1363       GParamSpecUInt64 *pspec = G_PARAM_SPEC_UINT64 (spec);
1364
1365       desc = g_strdup_printf ("%" G_GUINT64_FORMAT, pspec->default_value);
1366     }
1367   else if (G_IS_PARAM_SPEC_UNICHAR (spec))
1368     {
1369       GParamSpecUnichar *pspec = G_PARAM_SPEC_UNICHAR (spec);
1370
1371       if (g_unichar_isprint (pspec->default_value))
1372         desc = g_strdup_printf ("'%c'", pspec->default_value);
1373       else
1374         desc = g_strdup_printf ("%u", pspec->default_value);
1375     }
1376   else if (G_IS_PARAM_SPEC_ENUM (spec))
1377     {
1378       GParamSpecEnum *pspec = G_PARAM_SPEC_ENUM (spec);
1379
1380       GEnumValue *value = g_enum_get_value (pspec->enum_class, pspec->default_value);
1381       if (value)
1382         desc = g_strdup_printf ("%s", value->value_name);
1383       else
1384         desc = g_strdup_printf ("%d", pspec->default_value);
1385     }
1386   else if (G_IS_PARAM_SPEC_FLAGS (spec))
1387     {
1388       GParamSpecFlags *pspec = G_PARAM_SPEC_FLAGS (spec);
1389       guint default_value;
1390       GString *acc;
1391
1392       default_value = pspec->default_value;
1393       acc = g_string_new ("");
1394
1395       while (default_value)
1396         {
1397           GFlagsValue *value = g_flags_get_first_value (pspec->flags_class, default_value);
1398
1399           if (!value)
1400             break;
1401
1402           if (acc->len > 0)
1403             g_string_append (acc, "|");
1404           g_string_append (acc, value->value_name);
1405
1406           default_value &= ~value->value;
1407         }
1408
1409       if (default_value == 0)
1410         desc = g_string_free (acc, FALSE);
1411       else
1412         {
1413           desc = g_strdup_printf ("%d", pspec->default_value);
1414           g_string_free (acc, TRUE);
1415         }
1416     }
1417   else if (G_IS_PARAM_SPEC_FLOAT (spec))
1418     {
1419       GParamSpecFloat *pspec = G_PARAM_SPEC_FLOAT (spec);
1420
1421       desc = g_strdup_printf ("%g", pspec->default_value);
1422     }
1423   else if (G_IS_PARAM_SPEC_DOUBLE (spec))
1424     {
1425       GParamSpecDouble *pspec = G_PARAM_SPEC_DOUBLE (spec);
1426
1427       desc = g_strdup_printf ("%lg", pspec->default_value);
1428     }
1429   else if (G_IS_PARAM_SPEC_STRING (spec))
1430     {
1431       GParamSpecString *pspec = G_PARAM_SPEC_STRING (spec);
1432
1433       if (pspec->default_value)
1434         {
1435           gchar *esc = g_strescape (pspec->default_value, NULL);
1436
1437           desc = g_strdup_printf ("\\"%s\\"", esc);
1438
1439           g_free (esc);
1440         }
1441       else
1442         desc = g_strdup_printf ("NULL");
1443     }
1444   else
1445     {
1446       desc = g_strdup ("");
1447     }
1448
1449   return desc;
1450 }
1451
1452
1453 static void
1454 output_object_args (FILE *fp, GType object_type)
1455 {
1456   gpointer class;
1457   const gchar *object_class_name;
1458   guint arg;
1459   gchar flags[16], *pos;
1460   GParamSpec **properties;
1461   guint n_properties;
1462   gboolean child_prop;
1463   gboolean style_prop;
1464   gboolean is_pointer;
1465   const gchar *type_name;
1466   gchar *type_desc;
1467   gchar *default_value;
1468
1469   if (G_TYPE_IS_OBJECT (object_type))
1470     {
1471       class = g_type_class_peek (object_type);
1472       if (!class)
1473         return;
1474
1475       properties = g_object_class_list_properties (class, &n_properties);
1476     }
1477 #if GLIB_MAJOR_VERSION > 2 || (GLIB_MAJOR_VERSION == 2 && GLIB_MINOR_VERSION >= 3)
1478   else if (G_TYPE_IS_INTERFACE (object_type))
1479     {
1480       class = g_type_default_interface_ref (object_type);
1481
1482       if (!class)
1483         return;
1484
1485       properties = g_object_interface_list_properties (class, &n_properties);
1486     }
1487 #endif
1488   else
1489     return;
1490
1491   object_class_name = g_type_name (object_type);
1492
1493   child_prop = FALSE;
1494   style_prop = FALSE;
1495
1496   while (TRUE) {
1497     qsort (properties, n_properties, sizeof (GParamSpec *), compare_param_specs);
1498     for (arg = 0; arg < n_properties; arg++)
1499       {
1500         GParamSpec *spec = properties[arg];
1501         const gchar *nick, *blurb, *dot;
1502
1503         if (spec->owner_type != object_type)
1504           continue;
1505
1506         pos = flags;
1507         /* We use one-character flags for simplicity. */
1508         if (child_prop && !style_prop)
1509           *pos++ = 'c';
1510         if (style_prop)
1511           *pos++ = 's';
1512         if (spec->flags & G_PARAM_READABLE)
1513           *pos++ = 'r';
1514         if (spec->flags & G_PARAM_WRITABLE)
1515           *pos++ = 'w';
1516         if (spec->flags & G_PARAM_CONSTRUCT)
1517           *pos++ = 'x';
1518         if (spec->flags & G_PARAM_CONSTRUCT_ONLY)
1519           *pos++ = 'X';
1520         *pos = 0;
1521
1522         nick = g_param_spec_get_nick (spec);
1523         blurb = g_param_spec_get_blurb (spec);
1524
1525         dot = "";
1526         if (blurb) {
1527           int str_len = strlen (blurb);
1528           if (str_len > 0  && blurb[str_len - 1] != '.')
1529             dot = ".";
1530         }
1531
1532         type_desc = describe_type (spec);
1533         default_value = describe_default (spec);
1534         type_name = get_type_name (spec->value_type, &is_pointer);
1535         fprintf (fp, "<ARG>\\n<NAME>%s::%s</NAME>\\n<TYPE>%s%s</TYPE>\\n<RANGE>%s</RANGE>\\n<FLAGS>%s</FLAGS>\\n<NICK>%s</NICK>\\n<BLURB>%s%s</BLURB>\\n<DEFAULT>%s</DEFAULT>\\n</ARG>\\n\\n",
1536                  object_class_name, g_param_spec_get_name (spec), type_name, is_pointer ? "*" : "", type_desc, flags, nick ? nick : "(null)", blurb ? blurb : "(null)", dot, default_value);
1537         g_free (type_desc);
1538         g_free (default_value);
1539       }
1540
1541     g_free (properties);
1542
1543 #ifdef GTK_IS_CONTAINER_CLASS
1544     if (!child_prop && GTK_IS_CONTAINER_CLASS (class)) {
1545       properties = gtk_container_class_list_child_properties (class, &n_properties);
1546       child_prop = TRUE;
1547       continue;
1548     }
1549 #endif
1550
1551 #ifdef GTK_IS_WIDGET_CLASS
1552 #if GTK_CHECK_VERSION(2,1,0)
1553     if (!style_prop && GTK_IS_WIDGET_CLASS (class)) {
1554       properties = gtk_widget_class_list_style_properties (GTK_WIDGET_CLASS (class), &n_properties);
1555       style_prop = TRUE;
1556       continue;
1557     }
1558 #endif
1559 #endif
1560
1561 EOT
1562
1563 if ($QUERY_CHILD_PROPERTIES) {
1564   print OUTPUT <<EOT;
1565     if (!child_prop) {
1566       properties = $QUERY_CHILD_PROPERTIES (class, &n_properties);
1567       if (properties) {
1568         child_prop = TRUE;
1569         continue;
1570       }
1571    }
1572
1573 EOT
1574 }
1575
1576 print OUTPUT <<EOT;
1577     break;
1578   }
1579 }
1580 EOT
1581
1582 close OUTPUT;
1583
1584 # Compile and run our file
1585
1586 $CC = $ENV{CC} ? $ENV{CC} : "gcc";
1587 $LD = $ENV{LD} ? $ENV{LD} : $CC;
1588 $CFLAGS = $ENV{CFLAGS} ? $ENV{CFLAGS} : "";
1589 $LDFLAGS = $ENV{LDFLAGS} ? $ENV{LDFLAGS} : "";
1590 $RUN = $ENV{RUN} ? $ENV{RUN} : "";
1591
1592 my $o_file;
1593 if ($CC =~ /libtool/) {
1594   $o_file  = "$MODULE-scan.lo"
1595 } else {
1596   $o_file = "$MODULE-scan.o"
1597 }
1598
1599 print "gtk-doc: Compiling scanner\n";
1600 $command = "$CC $CFLAGS -c -o $o_file $MODULE-scan.c";
1601 system($command) == 0 or die "Compilation of scanner failed: $!\n";
1602
1603 print "gtk-doc: Linking scanner\n";
1604 $command = "$LD -o $MODULE-scan $o_file $LDFLAGS";
1605 system($command) == 0 or die "Linking of scanner failed: $!\n";
1606
1607 print "gtk-doc: Running scanner $MODULE-scan\n";
1608 # use sh -c to avoid terminating the whole run without seeing the error
1609 system("sh -c \"$RUN ./$MODULE-scan\"") == 0 or die "Scan failed: $!\n";
1610
1611 if (!defined($ENV{"GTK_DOC_KEEP_INTERMEDIATE"})) {
1612   unlink "./$MODULE-scan.c", "./$MODULE-scan.o", "./$MODULE-scan.lo", "./$MODULE-scan";
1613 }
1614
1615 &UpdateFileIfChanged ($old_signals_filename, $new_signals_filename, 0);
1616 &UpdateFileIfChanged ($old_hierarchy_filename, $new_hierarchy_filename, 0);
1617 &UpdateFileIfChanged ($old_interfaces_filename, $new_interfaces_filename, 0);
1618 &UpdateFileIfChanged ($old_prerequisites_filename, $new_prerequisites_filename, 0);
1619 &UpdateFileIfChanged ($old_args_filename, $new_args_filename, 0);
1620
1621