mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-09 05:38:58 +00:00
Original commit message from CVS: A hopeless attempt at fixing the plugin docs Makefiles... Make the jpeg decoder a bit more aware about the different YUV colorspaces.
873 lines
22 KiB
Perl
Executable file
873 lines
22 KiB
Perl
Executable file
#!/usr/bin/perl -w
|
|
#
|
|
# gtk-doc - GTK DocBook documentation generator.
|
|
# Copyright (C) 1998 Damon Chaplin
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
#
|
|
|
|
#
|
|
# This gets information about object heirarchies and signals
|
|
# by compiling a small C program. CFLAGS and LDFLAGS must be
|
|
# set appropriately before running this script.
|
|
#
|
|
# NOTE: the lookup_signal_srg_names() function contains the argument names of
|
|
# standard GTK signal handlers. This may need to be updated for new
|
|
# GTK signals or Gnome widget signals.
|
|
|
|
use Getopt::Long;
|
|
|
|
# Options
|
|
|
|
# name of documentation module
|
|
my $MODULE;
|
|
my $OUTPUT_DIR;
|
|
|
|
%optctl = (module => \$MODULE,
|
|
types => \$TYPES_FILE,
|
|
nogtkinit => \$NO_GTK_INIT);
|
|
|
|
GetOptions(\%optctl, "module=s", "types:s", "nogtkinit");
|
|
|
|
$TYPES_FILE = $TYPES_FILE ? $TYPES_FILE : "$MODULE.types";
|
|
|
|
open TYPES, $TYPES_FILE || die "Cannot open $TYPES_FILE: $!\n";
|
|
open OUTPUT, ">$MODULE-scan.c" || die "Cannot open $MODULE-scan.c: $!\n";
|
|
|
|
# write a C program to scan the types
|
|
|
|
$includes = "";
|
|
@types = ();
|
|
|
|
for (<TYPES>) {
|
|
if (/^#include/) {
|
|
$includes .= $_;
|
|
} elsif (/^%/) {
|
|
next;
|
|
} elsif (/^\s*$/) {
|
|
next;
|
|
} else {
|
|
chomp;
|
|
push @types, $_;
|
|
}
|
|
}
|
|
|
|
$ntypes = @types + 1;
|
|
|
|
print OUTPUT <<EOT;
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
$includes
|
|
GtkType object_types[$ntypes];
|
|
GstElement *elements[$ntypes];
|
|
|
|
gint _typenr = 0;
|
|
|
|
gboolean
|
|
get_plugins ()
|
|
{
|
|
gint i = 0;
|
|
EOT
|
|
|
|
for (@types) {
|
|
print OUTPUT " gst_plugin_load(\"$_\");\n";
|
|
print OUTPUT " elements[i] = gst_elementfactory_make(\"$_\", \"dummy\");\n";
|
|
print OUTPUT " object_types[i] = GTK_OBJECT_TYPE(GTK_OBJECT(elements[i]));\n";
|
|
print OUTPUT " i++; \n";
|
|
}
|
|
print OUTPUT " object_types[i] = 0;\n";
|
|
|
|
print OUTPUT <<EOT;
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* This uses GTK type functions to output signal prototypes and the widget
|
|
* hierarchy.
|
|
*/
|
|
|
|
/* The output files */
|
|
gchar *signals_filename = "$MODULE.signals";
|
|
gchar *hierarchy_filename = "$MODULE.hierarchy";
|
|
gchar *args_filename = "$MODULE.args";
|
|
gchar *pads_filename = "$MODULE.pads";
|
|
|
|
|
|
static void output_signals ();
|
|
static void output_widget_signals (FILE *fp,
|
|
GtkType object_type);
|
|
static void output_widget_signal (FILE *fp,
|
|
GtkType object_type,
|
|
gchar *object_class_name,
|
|
guint signal_id);
|
|
static gchar * get_type_name (GtkType type,
|
|
gboolean * is_pointer);
|
|
static gchar * get_gdk_event (const gchar * signal_name);
|
|
static gchar ** lookup_signal_arg_names (gchar * type,
|
|
const gchar * signal_name);
|
|
|
|
static void output_widget_hierarchy ();
|
|
static void output_hierarchy (FILE *fp,
|
|
GtkType type,
|
|
gint level);
|
|
|
|
static void output_args ();
|
|
static void output_widget_args (FILE *fp, GtkType object_type);
|
|
|
|
static void output_pads ();
|
|
static void output_widget_pads (FILE *fp, GstElement *element);
|
|
|
|
int
|
|
main (int argc, char *argv[])
|
|
{
|
|
EOT
|
|
|
|
if ($NO_GTK_INIT) {
|
|
print OUTPUT <<EOT;
|
|
gtk_type_init ();
|
|
EOT
|
|
} else {
|
|
print OUTPUT <<EOT;
|
|
gtk_init (&argc, &argv);
|
|
EOT
|
|
}
|
|
|
|
print OUTPUT <<EOT;
|
|
gst_init (&argc, &argv);
|
|
get_plugins();
|
|
|
|
output_widget_hierarchy ();
|
|
output_signals ();
|
|
output_args ();
|
|
output_pads ();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void
|
|
output_signals ()
|
|
{
|
|
FILE *fp;
|
|
gint i;
|
|
|
|
fp = fopen (signals_filename, "w");
|
|
if (fp == NULL)
|
|
{
|
|
g_warning ("Couldn't open output file: %s", signals_filename);
|
|
return;
|
|
}
|
|
|
|
for (i = 0; object_types[i]; i++)
|
|
output_widget_signals (fp, object_types[i]);
|
|
|
|
fclose (fp);
|
|
}
|
|
|
|
|
|
/* This outputs all the signals of one widget. */
|
|
static void
|
|
output_widget_signals (FILE *fp, GtkType object_type)
|
|
{
|
|
GtkObjectClass *class;
|
|
gchar *object_class_name;
|
|
guint sig;
|
|
|
|
class = gtk_type_class (object_type);
|
|
if (!class || class->nsignals == 0)
|
|
return;
|
|
|
|
object_class_name = gtk_type_name (object_type);
|
|
|
|
for (sig = 0; sig < class->nsignals; sig++)
|
|
{
|
|
if (!class->signals[sig])
|
|
{
|
|
/*g_print ("Signal slot [%u] is empty\n", sig);*/
|
|
continue;
|
|
}
|
|
|
|
output_widget_signal (fp, object_type, object_class_name,
|
|
class->signals[sig]);
|
|
}
|
|
}
|
|
|
|
|
|
/* This outputs one signal. */
|
|
static void
|
|
output_widget_signal (FILE *fp,
|
|
GtkType object_type,
|
|
gchar *object_name,
|
|
guint signal_id)
|
|
{
|
|
GtkSignalQuery *query_info;
|
|
gchar *ret_type, *pos, *type_name, *arg_name, *object_arg, *object_arg_start;
|
|
gboolean is_pointer;
|
|
gchar ret_type_buffer[1024], buffer[1024];
|
|
gint i, param;
|
|
gchar **arg_names;
|
|
gint param_num, widget_num, event_num, callback_num;
|
|
gint *arg_num;
|
|
gchar signal_name[128];
|
|
|
|
|
|
/* g_print ("Object: %s Type: %i Signal: %u\n", object_name, object_type,
|
|
signal_id);*/
|
|
|
|
param_num = 1;
|
|
widget_num = event_num = callback_num = 0;
|
|
|
|
query_info = gtk_signal_query (signal_id);
|
|
if (query_info == NULL)
|
|
{
|
|
g_warning ("Couldn't query signal");
|
|
return;
|
|
}
|
|
|
|
/* Output the return type and function name. */
|
|
ret_type = get_type_name (query_info->return_val, &is_pointer);
|
|
sprintf (ret_type_buffer, "%s%s", ret_type, is_pointer ? "*" : "");
|
|
|
|
/* Output the signal object type and the argument name. We assume the
|
|
type is a pointer - I think that is OK. We remove "Gtk" or "Gnome" and
|
|
convert to lower case for the argument name. */
|
|
pos = buffer;
|
|
sprintf (pos, "%s ", object_name);
|
|
pos += strlen (pos);
|
|
|
|
if (!strncmp (object_name, "Gtk", 3))
|
|
object_arg = object_name + 3;
|
|
else if (!strncmp (object_name, "Gnome", 5))
|
|
object_arg = object_name + 5;
|
|
else
|
|
object_arg = object_name;
|
|
|
|
object_arg_start = pos;
|
|
sprintf (pos, "*%s\n", object_arg);
|
|
pos += strlen (pos);
|
|
g_strdown (object_arg_start);
|
|
if (!strcmp (object_arg_start, "widget"))
|
|
widget_num++;
|
|
|
|
/* Convert signal name to use underscores rather than dashes '-'. */
|
|
strcpy (signal_name, query_info->signal_name);
|
|
for (i = 0; signal_name[i]; i++)
|
|
{
|
|
if (signal_name[i] == '-')
|
|
signal_name[i] = '_';
|
|
}
|
|
|
|
/* Output the signal parameters. */
|
|
arg_names = lookup_signal_arg_names (object_name, signal_name);
|
|
|
|
for (param = 0; param < query_info->nparams; param++)
|
|
{
|
|
if (arg_names)
|
|
{
|
|
sprintf (pos, "%s\n", arg_names[param]);
|
|
pos += strlen (pos);
|
|
}
|
|
else
|
|
{
|
|
type_name = get_type_name (query_info->params[param], &is_pointer);
|
|
|
|
/* Most arguments to the callback are called "arg1", "arg2", etc.
|
|
GdkWidgets are called "widget", "widget2", ...
|
|
GdkEvents are called "event", "event2", ...
|
|
GtkCallbacks are called "callback", "callback2", ... */
|
|
if (!strcmp (type_name, "GtkWidget"))
|
|
{
|
|
arg_name = "widget";
|
|
arg_num = &widget_num;
|
|
}
|
|
else if (!strcmp (type_name, "GdkEvent"))
|
|
{
|
|
type_name = get_gdk_event (signal_name);
|
|
arg_name = "event";
|
|
arg_num = &event_num;
|
|
is_pointer = TRUE;
|
|
}
|
|
else if (!strcmp (type_name, "GtkCallback")
|
|
|| !strcmp (type_name, "GtkCCallback"))
|
|
{
|
|
arg_name = "callback";
|
|
arg_num = &callback_num;
|
|
}
|
|
else
|
|
{
|
|
arg_name = "arg";
|
|
arg_num = ¶m_num;
|
|
}
|
|
sprintf (pos, "%s ", type_name);
|
|
pos += strlen (pos);
|
|
|
|
if (!arg_num || *arg_num == 0)
|
|
sprintf (pos, "%s%s\n", is_pointer ? "*" : " ", arg_name);
|
|
else
|
|
sprintf (pos, "%s%s%i\n", is_pointer ? "*" : " ", arg_name,
|
|
*arg_num);
|
|
pos += strlen (pos);
|
|
|
|
if (arg_num)
|
|
*arg_num += 1;
|
|
}
|
|
}
|
|
|
|
fprintf (fp,
|
|
"<SIGNAL>\n<NAME>%s::%s</NAME>\n<RETURNS>%s</RETURNS>\n%s</SIGNAL>\n\n",
|
|
object_name, query_info->signal_name, ret_type_buffer, buffer);
|
|
g_free (query_info);
|
|
}
|
|
|
|
|
|
static gchar *
|
|
get_type_name (GtkType type, gboolean * is_pointer)
|
|
{
|
|
static gchar *GbTypeNames[] =
|
|
{
|
|
"char", "gchar",
|
|
"bool", "gboolean",
|
|
"int", "gint",
|
|
"uint", "guint",
|
|
"long", "glong",
|
|
"ulong", "gulong",
|
|
"float", "gfloat",
|
|
"double", "gdouble",
|
|
"string", "gchar",
|
|
"enum", "gint",
|
|
"flags", "gint",
|
|
"boxed", "gpointer",
|
|
"foreign", "gpointer",
|
|
"callback", "GtkCallback", /* ?? */
|
|
"args", "gpointer",
|
|
|
|
"pointer", "gpointer",
|
|
"signal", "gpointer",
|
|
"c_callback", "GtkCallback", /* ?? */
|
|
|
|
NULL
|
|
};
|
|
|
|
GtkType parent_type;
|
|
gchar *type_name, *parent_type_name;
|
|
gint i;
|
|
|
|
*is_pointer = FALSE;
|
|
type_name = gtk_type_name (type);
|
|
for (i = 0; GbTypeNames[i]; i += 2)
|
|
{
|
|
if (!strcmp (type_name, GbTypeNames[i]))
|
|
{
|
|
if (!strcmp (type_name, "string"))
|
|
*is_pointer = TRUE;
|
|
return GbTypeNames[i + 1];
|
|
}
|
|
}
|
|
|
|
for (;;)
|
|
{
|
|
parent_type = gtk_type_parent (type);
|
|
if (parent_type == 0)
|
|
break;
|
|
type = parent_type;
|
|
}
|
|
parent_type_name = gtk_type_name (type);
|
|
/*g_print ("Parent type name: %s\n", parent_type_name);*/
|
|
if (!strcmp (parent_type_name, "GtkObject")
|
|
|| !strcmp (parent_type_name, "boxed")
|
|
|| !strcmp (parent_type_name, "GtkBoxed"))
|
|
*is_pointer = TRUE;
|
|
|
|
return type_name;
|
|
}
|
|
|
|
|
|
static gchar *
|
|
get_gdk_event (const gchar * signal_name)
|
|
{
|
|
static gchar *GbGDKEvents[] =
|
|
{
|
|
"button_press_event", "GdkEventButton",
|
|
"button_release_event", "GdkEventButton",
|
|
"motion_notify_event", "GdkEventMotion",
|
|
"delete_event", "GdkEvent",
|
|
"destroy_event", "GdkEvent",
|
|
"expose_event", "GdkEventExpose",
|
|
"key_press_event", "GdkEventKey",
|
|
"key_release_event", "GdkEventKey",
|
|
"enter_notify_event", "GdkEventCrossing",
|
|
"leave_notify_event", "GdkEventCrossing",
|
|
"configure_event", "GdkEventConfigure",
|
|
"focus_in_event", "GdkEventFocus",
|
|
"focus_out_event", "GdkEventFocus",
|
|
"map_event", "GdkEvent",
|
|
"unmap_event", "GdkEvent",
|
|
"property_notify_event", "GdkEventProperty",
|
|
"selection_clear_event", "GdkEventSelection",
|
|
"selection_request_event", "GdkEventSelection",
|
|
"selection_notify_event", "GdkEventSelection",
|
|
"proximity_in_event", "GdkEventProximity",
|
|
"proximity_out_event", "GdkEventProximity",
|
|
"drag_begin_event", "GdkEventDragBegin",
|
|
"drag_request_event", "GdkEventDragRequest",
|
|
"drag_end_event", "GdkEventDragRequest",
|
|
"drop_enter_event", "GdkEventDropEnter",
|
|
"drop_leave_event", "GdkEventDropLeave",
|
|
"drop_data_available_event", "GdkEventDropDataAvailable",
|
|
"other_event", "GdkEventOther",
|
|
"client_event", "GdkEventClient",
|
|
"no_expose_event", "GdkEventNoExpose",
|
|
NULL
|
|
};
|
|
|
|
gint i;
|
|
|
|
for (i = 0; GbGDKEvents[i]; i += 2)
|
|
{
|
|
if (!strcmp (signal_name, GbGDKEvents[i]))
|
|
return GbGDKEvents[i + 1];
|
|
}
|
|
return "GdkEvent";
|
|
}
|
|
|
|
|
|
/* This returns argument names to use for some known GTK signals.
|
|
It is passed a widget name, e.g. 'GtkCList' and a signal name, e.g.
|
|
'select_row' and it returns a pointer to an array of argument types and
|
|
names. */
|
|
static gchar **
|
|
lookup_signal_arg_names (gchar * type, const gchar * signal_name)
|
|
{
|
|
/* Each arg array starts with the object type name and the signal name,
|
|
and then signal arguments follow. */
|
|
static gchar *GbArgTable[][16] =
|
|
{
|
|
{"GtkCList", "select_row",
|
|
"gint row",
|
|
"gint column",
|
|
"GdkEventButton *event"},
|
|
{"GtkCList", "unselect_row",
|
|
"gint row",
|
|
"gint column",
|
|
"GdkEventButton *event"},
|
|
{"GtkCList", "click_column",
|
|
"gint column"},
|
|
|
|
{"GtkCList", "resize_column",
|
|
"gint column",
|
|
"gint width"},
|
|
|
|
{"GtkCList", "extend_selection",
|
|
"GtkScrollType scroll_type",
|
|
"gfloat position",
|
|
"gboolean auto_start_selection"},
|
|
{"GtkCList", "scroll_vertical",
|
|
"GtkScrollType scroll_type",
|
|
"gfloat position"},
|
|
{"GtkCList", "scroll_horizontal",
|
|
"GtkScrollType scroll_type",
|
|
"gfloat position"},
|
|
{"GtkContainer", "focus",
|
|
"GtkDirectionType direction"},
|
|
{"GtkCTree", "tree_select_row",
|
|
"GList *node",
|
|
"gint column"},
|
|
{"GtkCTree", "tree_unselect_row",
|
|
"GList *node",
|
|
"gint column"},
|
|
|
|
{"GtkCTree", "tree_expand",
|
|
"GList *node"},
|
|
{"GtkCTree", "tree_collapse",
|
|
"GList *node"},
|
|
{"GtkCTree", "tree_move",
|
|
"GList *node",
|
|
"GList *new_parent",
|
|
"GList *new_sibling"},
|
|
{"GtkCTree", "change_focus_row_expansion",
|
|
"GtkCTreeExpansionType expansion"},
|
|
|
|
{"GtkEditable", "insert_text",
|
|
"gchar *new_text",
|
|
"gint new_text_length",
|
|
"gint *position"},
|
|
{"GtkEditable", "delete_text",
|
|
"gint start_pos",
|
|
"gint end_pos"},
|
|
{"GtkEditable", "set_editable",
|
|
"gboolean is_editable"},
|
|
{"GtkEditable", "move_cursor",
|
|
"gint x",
|
|
"gint y"},
|
|
{"GtkEditable", "move_word",
|
|
"gint num_words"},
|
|
{"GtkEditable", "move_page",
|
|
"gint x",
|
|
"gint y"},
|
|
{"GtkEditable", "move_to_row",
|
|
"gint row"},
|
|
{"GtkEditable", "move_to_column",
|
|
"gint column"},
|
|
|
|
{"GtkEditable", "kill_char",
|
|
"gint direction"},
|
|
{"GtkEditable", "kill_word",
|
|
"gint direction"},
|
|
{"GtkEditable", "kill_line",
|
|
"gint direction"},
|
|
|
|
|
|
{"GtkInputDialog", "enable_device",
|
|
"gint deviceid"},
|
|
{"GtkInputDialog", "disable_device",
|
|
"gint deviceid"},
|
|
|
|
{"GtkListItem", "extend_selection",
|
|
"GtkScrollType scroll_type",
|
|
"gfloat position",
|
|
"gboolean auto_start_selection"},
|
|
{"GtkListItem", "scroll_vertical",
|
|
"GtkScrollType scroll_type",
|
|
"gfloat position"},
|
|
{"GtkListItem", "scroll_horizontal",
|
|
"GtkScrollType scroll_type",
|
|
"gfloat position"},
|
|
|
|
{"GtkMenuShell", "move_current",
|
|
"GtkMenuDirectionType direction"},
|
|
{"GtkMenuShell", "activate_current",
|
|
"gboolean force_hide"},
|
|
|
|
|
|
{"GtkNotebook", "switch_page",
|
|
"GtkNotebookPage *page",
|
|
"gint page_num"},
|
|
{"GtkStatusbar", "text_pushed",
|
|
"guint context_id",
|
|
"gchar *text"},
|
|
{"GtkStatusbar", "text_popped",
|
|
"guint context_id",
|
|
"gchar *text"},
|
|
{"GtkTipsQuery", "widget_entered",
|
|
"GtkWidget *widget",
|
|
"gchar *tip_text",
|
|
"gchar *tip_private"},
|
|
{"GtkTipsQuery", "widget_selected",
|
|
"GtkWidget *widget",
|
|
"gchar *tip_text",
|
|
"gchar *tip_private",
|
|
"GdkEventButton *event"},
|
|
{"GtkToolbar", "orientation_changed",
|
|
"GtkOrientation orientation"},
|
|
{"GtkToolbar", "style_changed",
|
|
"GtkToolbarStyle style"},
|
|
{"GtkWidget", "draw",
|
|
"GdkRectangle *area"},
|
|
{"GtkWidget", "size_request",
|
|
"GtkRequisition *requisition"},
|
|
{"GtkWidget", "size_allocate",
|
|
"GtkAllocation *allocation"},
|
|
{"GtkWidget", "state_changed",
|
|
"GtkStateType state"},
|
|
{"GtkWidget", "style_set",
|
|
"GtkStyle *previous_style"},
|
|
|
|
{"GtkWidget", "install_accelerator",
|
|
"gchar *signal_name",
|
|
"gchar key",
|
|
"gint modifiers"},
|
|
|
|
{"GtkWidget", "add_accelerator",
|
|
"guint accel_signal_id",
|
|
"GtkAccelGroup *accel_group",
|
|
"guint accel_key",
|
|
"GdkModifierType accel_mods",
|
|
"GtkAccelFlags accel_flags"},
|
|
|
|
{"GtkWidget", "parent_set",
|
|
"GtkObject *old_parent"},
|
|
|
|
{"GtkWidget", "remove_accelerator",
|
|
"GtkAccelGroup *accel_group",
|
|
"guint accel_key",
|
|
"GdkModifierType accel_mods"},
|
|
{"GtkWidget", "debug_msg",
|
|
"gchar *message"},
|
|
{"GtkWindow", "move_resize",
|
|
"gint *x",
|
|
"gint *y",
|
|
"gint width",
|
|
"gint height"},
|
|
{"GtkWindow", "set_focus",
|
|
"GtkWidget *widget"},
|
|
|
|
{"GtkWidget", "selection_get",
|
|
"GtkSelectionData *data",
|
|
"guint info",
|
|
"guint time"},
|
|
{"GtkWidget", "selection_received",
|
|
"GtkSelectionData *data",
|
|
"guint time"},
|
|
|
|
{"GtkWidget", "drag_begin",
|
|
"GdkDragContext *drag_context"},
|
|
{"GtkWidget", "drag_end",
|
|
"GdkDragContext *drag_context"},
|
|
{"GtkWidget", "drag_data_delete",
|
|
"GdkDragContext *drag_context"},
|
|
{"GtkWidget", "drag_leave",
|
|
"GdkDragContext *drag_context",
|
|
"guint time"},
|
|
{"GtkWidget", "drag_motion",
|
|
"GdkDragContext *drag_context",
|
|
"gint x",
|
|
"gint y",
|
|
"guint time"},
|
|
{"GtkWidget", "drag_drop",
|
|
"GdkDragContext *drag_context",
|
|
"gint x",
|
|
"gint y",
|
|
"guint time"},
|
|
{"GtkWidget", "drag_data_get",
|
|
"GdkDragContext *drag_context",
|
|
"GtkSelectionData *data",
|
|
"guint info",
|
|
"guint time"},
|
|
{"GtkWidget", "drag_data_received",
|
|
"GdkDragContext *drag_context",
|
|
"gint x",
|
|
"gint y",
|
|
"GtkSelectionData *data",
|
|
"guint info",
|
|
"guint time"},
|
|
|
|
{NULL}
|
|
};
|
|
|
|
gint i;
|
|
|
|
for (i = 0; GbArgTable[i][0]; i++)
|
|
{
|
|
if (!strcmp (type, GbArgTable[i][0])
|
|
&& !strcmp (signal_name, GbArgTable[i][1]))
|
|
return &GbArgTable[i][2];
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/* This outputs the hierarchy of all widgets which have been initialized,
|
|
i.e. by calling their XXX_get_type() initialization function. */
|
|
static void
|
|
output_widget_hierarchy ()
|
|
{
|
|
FILE *fp;
|
|
|
|
fp = fopen (hierarchy_filename, "w");
|
|
if (fp == NULL)
|
|
{
|
|
g_warning ("Couldn't open output file: %s", hierarchy_filename);
|
|
return;
|
|
}
|
|
output_hierarchy (fp, GTK_TYPE_OBJECT, 0);
|
|
fclose (fp);
|
|
}
|
|
|
|
|
|
/* This is called recursively to output the hierarchy of a widget. */
|
|
static void
|
|
output_hierarchy (FILE *fp,
|
|
GtkType type,
|
|
gint level)
|
|
{
|
|
GList *list;
|
|
guint i;
|
|
|
|
if (!type)
|
|
return;
|
|
|
|
for (i = 0; i < level; i++)
|
|
fprintf (fp, " ");
|
|
fprintf (fp, gtk_type_name (type));
|
|
fprintf (fp, "\n");
|
|
|
|
list = gtk_type_children_types (type);
|
|
|
|
while (list)
|
|
{
|
|
GtkType child = (GtkType) list->data;
|
|
output_hierarchy (fp, child, level + 1);
|
|
list = list->next;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
output_args ()
|
|
{
|
|
FILE *fp;
|
|
gint i;
|
|
|
|
fp = fopen (args_filename, "w");
|
|
if (fp == NULL)
|
|
{
|
|
g_warning ("Couldn't open output file: %s", args_filename);
|
|
return;
|
|
}
|
|
|
|
for (i = 0; object_types[i]; i++)
|
|
output_widget_args (fp, object_types[i]);
|
|
|
|
fclose (fp);
|
|
}
|
|
|
|
|
|
static void
|
|
output_widget_args (FILE *fp, GtkType object_type)
|
|
{
|
|
GtkObjectClass *class;
|
|
gchar *object_class_name;
|
|
GtkArg *args;
|
|
guint32 *arg_flags;
|
|
guint n_args;
|
|
gint arg;
|
|
gchar flags[16], *pos;
|
|
|
|
class = gtk_type_class (object_type);
|
|
if (!class)
|
|
return;
|
|
|
|
object_class_name = gtk_type_name (object_type);
|
|
|
|
args = gtk_object_query_args (class->type, &arg_flags, &n_args);
|
|
|
|
for (arg = 0; arg < n_args; arg++)
|
|
{
|
|
pos = flags;
|
|
/* We use one-character flags for simplicity. */
|
|
if (arg_flags[arg] & GTK_ARG_READABLE)
|
|
*pos++ = 'r';
|
|
if (arg_flags[arg] & GTK_ARG_WRITABLE)
|
|
*pos++ = 'w';
|
|
if (arg_flags[arg] & GTK_ARG_CONSTRUCT)
|
|
*pos++ = 'x';
|
|
if (arg_flags[arg] & GTK_ARG_CONSTRUCT_ONLY)
|
|
*pos++ = 'X';
|
|
if (arg_flags[arg] & GTK_ARG_CHILD_ARG)
|
|
*pos++ = 'c';
|
|
*pos = '\0';
|
|
|
|
fprintf (fp, "<ARG>\n<NAME>%s</NAME>\n<TYPE>%s</TYPE>\n<FLAGS>%s</FLAGS>\n",
|
|
args[arg].name, gtk_type_name (args[arg].type), flags);
|
|
|
|
if (GTK_FUNDAMENTAL_TYPE(args[arg].type) == GTK_TYPE_ENUM) {
|
|
GtkEnumValue *values;
|
|
gint i=0;
|
|
|
|
values = gtk_type_enum_get_values(args[arg].type);
|
|
|
|
while (values[i].value_name) {
|
|
fprintf (fp, "<ENUM>\n<VALUE>%d</VALUE>\n<NICK>%s</NICK>\n</ENUM>\n",
|
|
values[i].value, values[i].value_nick);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
fprintf(fp, "</ARG>\n\n");
|
|
}
|
|
|
|
g_free (args);
|
|
g_free (arg_flags);
|
|
}
|
|
|
|
|
|
static void
|
|
output_pads ()
|
|
{
|
|
FILE *fp;
|
|
gint i;
|
|
|
|
fp = fopen (pads_filename, "w");
|
|
if (fp == NULL)
|
|
{
|
|
g_warning ("Couldn't open output file: %s", pads_filename);
|
|
return;
|
|
}
|
|
|
|
for (i = 0; elements[i]; i++)
|
|
output_widget_pads (fp, elements[i]);
|
|
|
|
fclose (fp);
|
|
}
|
|
|
|
static void
|
|
output_widget_pads (FILE *fp, GstElement *element)
|
|
{
|
|
GtkObjectClass *class;
|
|
GstElementFactory *factory;
|
|
GList *pads;
|
|
|
|
class = GTK_OBJECT(element)->klass;
|
|
if (!class || !GST_IS_ELEMENT_CLASS(class))
|
|
return;
|
|
|
|
pads = gst_element_get_pad_list(element);
|
|
|
|
factory = GST_ELEMENT_CLASS(class)->elementfactory;
|
|
|
|
if (!factory)
|
|
return;
|
|
|
|
while (pads) {
|
|
GstPad *pad = (GstPad *)pads->data;
|
|
GstType *type;
|
|
|
|
//type = gst_type_find_by_id(pad->type);
|
|
type = gst_type_find_by_id(1);
|
|
|
|
fprintf (fp, "<PAD>\n<NAME>%s::%s</NAME>\n",
|
|
gtk_type_name(factory->type), gst_object_get_name (GST_OBJECT (pad)));
|
|
|
|
if (type) {
|
|
fprintf(fp, "<MIME>%s</MIME>\n", type->mime);
|
|
if (type->exts)
|
|
fprintf(fp, "<EXTS>%s</EXTS>\n", type->exts);
|
|
}
|
|
|
|
fprintf(fp, "</PAD>\n\n");
|
|
|
|
pads = g_list_next(pads);
|
|
}
|
|
}
|
|
|
|
EOT
|
|
|
|
close OUTPUT;
|
|
|
|
# Compile and run our file
|
|
|
|
$CC = $ENV{CC} ? $ENV{CC} : "gcc";
|
|
$LD = $ENV{LD} ? $ENV{LD} : $CC;
|
|
$CFLAGS = $ENV{CFLAGS} ? $ENV{CFLAGS} : "";
|
|
$LDFLAGS = $ENV{LDFLAGS} ? $ENV{LDFLAGS} : "";
|
|
|
|
$command = "$CC $CFLAGS -c -o $MODULE-scan.o $MODULE-scan.c && $LD -o $MODULE-scan $MODULE-scan.o $LDFLAGS";
|
|
|
|
system($command) == 0 or die "Compilation of scanner failed\n";
|
|
|
|
system("./$MODULE-scan") == 0 or die "Scan failed\n";
|
|
|
|
unlink "./$MODULE-scan.c", "./$MODULE-scan",
|