自学教程：C++ GTK_IS_WIDGET函数代码示例

voidgimp_dialog_factory_hide_dialog (GtkWidget *dialog){  g_return_if_fail (GTK_IS_WIDGET (dialog));  g_return_if_fail (GTK_WIDGET_TOPLEVEL (dialog));  if (! gimp_dialog_factory_from_widget (dialog, NULL))    {      g_warning ("%s: dialog was not created by a GimpDialogFactory",                 G_STRFUNC);      return;    }  gtk_widget_hide (dialog);  if (! dialogs_shown)    g_object_set_data (G_OBJECT (dialog), GIMP_DIALOG_VISIBILITY_KEY,                       GINT_TO_POINTER (GIMP_DIALOG_VISIBILITY_INVISIBLE));}

gbooleangb_widget_activate_action (GtkWidget   *widget,                           const gchar *prefix,                           const gchar *action_name,                           GVariant    *parameter){    GApplication *app;    GtkWidget *toplevel;    GActionGroup *group = NULL;    g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);    g_return_val_if_fail (prefix, FALSE);    g_return_val_if_fail (action_name, FALSE);    app = g_application_get_default ();    toplevel = gtk_widget_get_toplevel (widget);    while ((group == NULL) && (widget != NULL))    {        group = gtk_widget_get_action_group (widget, prefix);        widget = gtk_widget_get_parent (widget);    }    if (!group && g_str_equal (prefix, "win") && G_IS_ACTION_GROUP (toplevel))        group = G_ACTION_GROUP (toplevel);    if (!group && g_str_equal (prefix, "app") && G_IS_ACTION_GROUP (app))        group = G_ACTION_GROUP (app);    if (group && g_action_group_has_action (group, action_name))    {        g_action_group_activate_action (group, action_name, parameter);        return TRUE;    }    if (parameter && g_variant_is_floating (parameter))    {        parameter = g_variant_ref_sink (parameter);        g_variant_unref (parameter);    }    return FALSE;}

static gbooleangb_vim_command_cprevious (GtkWidget      *active_widget,                          const gchar    *command,                          const gchar    *options,                          GError        **error){  g_assert (GTK_IS_WIDGET (active_widget));  if (IDE_IS_EDITOR_PAGE (active_widget))    {      IdeSourceView *source_view = ide_editor_page_get_view (IDE_EDITOR_PAGE (active_widget));      g_signal_emit_by_name (source_view, "move-error", GTK_DIR_UP);      return TRUE;    }  else    return gb_vim_set_source_view_error (error);}

static voidlyric_show_viewport_update_current_widget(LyricShowViewport *lsv){    if((!lsv->priv->is_pressed) && lsv->priv->current_widget)    {        GtkAllocation alc0,alc1;        const gchar *color_string = "blue";#if GTK_CHECK_VERSION(3,2,0)        GdkRGBA color = {0};        gdk_rgba_parse(&color,color_string);#else        GdkColor color = {0};        gdk_color_parse(color_string,&color);#endif        if(lsv->priv->pre_widget &&            GTK_IS_WIDGET(lsv->priv->pre_widget) &&            lsv->priv->current_widget !=lsv->priv->pre_widget)        {#if GTK_CHECK_VERSION(3,2,0)            gtk_widget_override_color(lsv->priv->pre_widget,GTK_STATE_FLAG_ACTIVE,NULL);            gtk_widget_set_state_flags(lsv->priv->pre_widget,GTK_STATE_FLAG_ACTIVE,FALSE);#else            gtk_widget_modify_fg(lsv->priv->pre_widget,GTK_STATE_ACTIVE,NULL);            gtk_widget_set_state(lsv->priv->pre_widget,GTK_STATE_NORMAL);#endif        }#if GTK_CHECK_VERSION(3,2,0)        gtk_widget_override_color(lsv->priv->current_widget,GTK_STATE_FLAG_ACTIVE,&color);        gtk_widget_set_state_flags(lsv->priv->current_widget,GTK_STATE_FLAG_ACTIVE,FALSE);#else        gtk_widget_modify_fg(lsv->priv->current_widget,GTK_STATE_ACTIVE,&color);        gtk_widget_set_state(lsv->priv->current_widget,GTK_STATE_ACTIVE);#endif        gtk_widget_get_allocation(lsv->priv->current_widget,&alc0);        gtk_widget_get_allocation(lsv->priv->lyricbox,&alc1);        lsv->priv->pos = (alc0.y - alc1.y)+alc0.height/2.0;        gtk_widget_queue_resize(GTK_WIDGET(lsv));    }}

/** * gtk_expander_set_label_widget: * @expander: a #GtkExpander * @label_widget: (allow-none): the new label widget * * Set the label widget for the expander. This is the widget * that will appear embedded alongside the expander arrow. * * Since: 2.4 **/voidgtk_expander_set_label_widget (GtkExpander *expander,			       GtkWidget   *label_widget){  GtkExpanderPrivate *priv;  GtkWidget          *widget;  g_return_if_fail (GTK_IS_EXPANDER (expander));  g_return_if_fail (label_widget == NULL || GTK_IS_WIDGET (label_widget));  g_return_if_fail (label_widget == NULL || label_widget->parent == NULL);  priv = expander->priv;  if (priv->label_widget == label_widget)    return;  if (priv->label_widget)    {      gtk_widget_set_state (priv->label_widget, GTK_STATE_NORMAL);      gtk_widget_unparent (priv->label_widget);    }  priv->label_widget = label_widget;  widget = GTK_WIDGET (expander);  if (label_widget)    {      priv->label_widget = label_widget;      gtk_widget_set_parent (label_widget, widget);      if (priv->prelight)	gtk_widget_set_state (label_widget, GTK_STATE_PRELIGHT);    }  if (gtk_widget_get_visible (widget))    gtk_widget_queue_resize (widget);  g_object_freeze_notify (G_OBJECT (expander));  g_object_notify (G_OBJECT (expander), "label-widget");  g_object_notify (G_OBJECT (expander), "label");  g_object_thaw_notify (G_OBJECT (expander));}

G_MODULE_EXPORT gboolean checkbutton_handler(GtkWidget *widget, gpointer data){	gboolean state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));	gint handler = (GINT)OBJ_GET((widget),"handler");	MtxGaugeFace *g = NULL;	if (GTK_IS_WIDGET(gauge))		g = MTX_GAUGE_FACE(gauge);	else 		return FALSE;	if (hold_handlers)		return TRUE;	changed = TRUE;	mtx_gauge_face_set_attribute(g,handler, state);	return TRUE;}

static voidon_file_view_show_popup_menu (AnjutaFileView* view, GFile* file,							  gboolean is_dir, guint button,							  guint32 time, AnjutaFileManager* file_manager){	GtkWidget *popup;	GtkWidget *rename;	AnjutaUI* ui = anjuta_shell_get_ui (ANJUTA_PLUGIN(file_manager)->shell, 										NULL);	popup = gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui),									   "/PopupFileManager");	rename = gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui),									   "/PopupFileManager/PopupFileManagerRename");	/* TODO */	gtk_widget_hide (rename);		g_return_if_fail (GTK_IS_WIDGET (popup));	gtk_menu_popup (GTK_MENU (popup), NULL, NULL, NULL, NULL, button, time);}

static void refresh_window_cb (G_GNUC_UNUSED GtkWidget *widget, gpointer data){    DEBUG_FUNCTION ("refresh_window_cb");    DEBUG_ASSERT (data != NULL);    GdkRectangle rect;    if (GTK_IS_WIDGET(data))    {        if (gtk_widget_get_window (GTK_WIDGET (data)))        {            rect.x = rect.y = 0;            GtkAllocation allocation;            gtk_widget_get_allocation (GTK_WIDGET (data), &allocation);            rect.width = allocation.width;            rect.height = allocation.height;            gdk_window_invalidate_rect (gtk_widget_get_window (GTK_WIDGET(data)), &rect, TRUE);        }    }}

GtkCssGadget *gtk_icon_helper_new_named (const char *name,                           GtkWidget  *owner){  GtkIconHelper *result;  GtkCssNode *node;  g_return_val_if_fail (name != NULL, NULL);  g_return_val_if_fail (GTK_IS_WIDGET (owner), NULL);  node = gtk_css_node_new ();  gtk_css_node_set_name (node, g_intern_string (name));  result = gtk_icon_helper_new (node, owner);  g_object_unref (node);  return GTK_CSS_GADGET (result);}

voidgtk_text_child_anchor_unregister_child (GtkTextChildAnchor *anchor,                                        GtkWidget          *child){  g_return_if_fail (GTK_IS_TEXT_CHILD_ANCHOR (anchor));  g_return_if_fail (GTK_IS_WIDGET (child));  CHECK_IN_BUFFER (anchor);    if (_gtk_anchored_child_get_layout (child))    {      gtk_text_child_anchor_queue_resize (anchor,                                          _gtk_anchored_child_get_layout (child));    }    _gtk_anchored_child_set_layout (child, NULL);    _gtk_widget_segment_remove (anchor->segment, child);}

voidppg_util_load_ui (GtkWidget       *widget,                  GtkActionGroup **actions,                  const gchar     *ui_data,                  const gchar     *first_widget,                  ...){	GtkUIManager *ui_manager;	GtkActionGroup *action_group;	GtkAccelGroup *accel_group;	const gchar *name;	GtkWidget **dst_widget;	GError *error = NULL;	GType type;	va_list args;	g_return_if_fail(GTK_IS_WIDGET(widget));	g_return_if_fail(ui_data != NULL);	g_return_if_fail(first_widget != NULL);	ui_manager = gtk_ui_manager_new();	if (!gtk_ui_manager_add_ui_from_string(ui_manager, ui_data, -1, &error)) {		g_error("%s", error->message); /* Fatal */	}	type = G_TYPE_FROM_INSTANCE(widget);	accel_group = gtk_ui_manager_get_accel_group(ui_manager);	action_group = gtk_action_group_new(g_type_name(type));	ppg_actions_load(widget, accel_group, action_group);	gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);	name = first_widget;	va_start(args, first_widget);	do {		dst_widget = va_arg(args, GtkWidget**);		*dst_widget = gtk_ui_manager_get_widget(ui_manager, name);	} while ((name = va_arg(args, const gchar*)));	if (actions) {		*actions = action_group;	}}

/** * eel_gtk_container_child_remove: * * @container: A GtkContainer widget. * @child: A non NULL child of @container. * * Remove @child from @container.  The @container is resized if needed. * This is usually called from the "GtkContainer::remove" method of the * @container.  The child cannot be NULL. */voideel_gtk_container_child_remove (GtkContainer *container,                                GtkWidget *child){    gboolean child_was_visible;    g_return_if_fail (GTK_IS_CONTAINER (container));    g_return_if_fail (GTK_IS_WIDGET (child));    g_return_if_fail (gtk_widget_get_parent (child) == GTK_WIDGET (container));    child_was_visible = gtk_widget_get_visible (child);    gtk_widget_unparent (child);    if (child_was_visible)    {        gtk_widget_queue_resize (GTK_WIDGET (container));    }}

EXPORT gboolean close_current_gauge(GtkWidget * widget, gpointer data){	GtkWidget *tmp = NULL;	GladeXML *xml = glade_get_widget_tree(widget);	GtkWidget *parent = glade_xml_get_widget(xml,"gauge_frame");	if (GTK_IS_WIDGET(gauge))	{		if (changed)			prompt_to_save();		gtk_widget_destroy(gauge);		gtk_widget_set_sensitive(glade_xml_get_widget(xml,"tab_notebook"),FALSE);		gauge_loaded = FALSE;		changed = FALSE;	}	gauge = NULL;	tmp = glade_xml_get_widget(xml,"animate_frame");	gtk_widget_set_sensitive(tmp,FALSE);	tmp = glade_xml_get_widget(xml,"new_gauge_menuitem");	gtk_widget_set_sensitive(tmp,TRUE);	tmp = glade_xml_get_widget(xml,"load_gauge_menuitem");	gtk_widget_set_sensitive(tmp,TRUE);	tmp = glade_xml_get_widget(xml,"close_gauge_menuitem");	gtk_widget_set_sensitive(tmp,FALSE);	tmp = glade_xml_get_widget(xml,"save_gauge_menuitem");	gtk_widget_set_sensitive(tmp,FALSE);	tmp = glade_xml_get_widget(xml,"save_as_menuitem");	gtk_widget_set_sensitive(tmp,FALSE);	tmp = glade_xml_get_widget(xml,"animate_button");	gtk_widget_set_sensitive(tmp,TRUE);	reset_onscreen_controls();	direct_path = FALSE;	gtk_widget_show_all(parent);	return (TRUE);}

static voidon_workbench_set_focus (GbCommandProvider *provider,                        GtkWidget         *widget,                        GbWorkbench       *workbench){  g_return_if_fail (GB_IS_COMMAND_PROVIDER (provider));  g_return_if_fail (GB_IS_WORKBENCH (workbench));  g_return_if_fail (!widget || GTK_IS_WIDGET (widget));  /* walk the hierarchy to find a tab */  if (widget)    while (!GB_IS_VIEW (widget))      if (!(widget = gtk_widget_get_parent (widget)))        break;  if (GB_IS_VIEW (widget))    gb_command_provider_set_active_view (provider,                                         GB_VIEW (widget));}

static void _lib_backgroundjobs_progress(dt_lib_module_t *self, const guint *key, double progress){  if(!darktable.control->running) return;  dt_lib_backgroundjobs_t *d = (dt_lib_backgroundjobs_t*)self->data;  gboolean i_own_lock = dt_control_gdk_lock();  dt_bgjob_t *j = (dt_bgjob_t*)g_hash_table_lookup(d->jobs, key);  if(j)  {    /* check if progress is above 1.0 and destroy bgjob if finished */    /* FIXME: actually we are having some rounding issues, where the */    /* FIXME: last item doesn't bring to total to 1.0 flat */    /* FIXME: so this is why we have the ugly kludge below */    if (progress > 0.999999)    {      if (GTK_IS_WIDGET(j->widget))        gtk_container_remove( GTK_CONTAINER(d->jobbox), j->widget );#ifdef HAVE_UNITY      unity_launcher_entry_set_progress( j->darktable_launcher, 1.0 );      unity_launcher_entry_set_progress_visible( j->darktable_launcher, FALSE );#endif#ifdef MAC_INTEGRATION      gtk_osxapplication_attention_request(g_object_new(GTK_TYPE_OSX_APPLICATION, NULL), INFO_REQUEST);#endif      /* hide jobbox if theres no jobs left */      if (g_list_length(gtk_container_get_children(GTK_CONTAINER(d->jobbox))) == 0 )        gtk_widget_hide(d->jobbox);    }    else    {      if( j->type == 0 )        gtk_progress_bar_set_fraction( GTK_PROGRESS_BAR(j->progressbar), progress );#ifdef HAVE_UNITY      unity_launcher_entry_set_progress( j->darktable_launcher, progress );#endif    }  }  if(i_own_lock) dt_control_gdk_unlock();}

GList *nautilus_menu_provider_get_file_items (NautilusMenuProvider *provider,                                       GtkWidget            *window,                                       GList                *files){    NautilusMenuProviderInterface *iface;    iface = NAUTILUS_MENU_PROVIDER_GET_IFACE (provider);    g_return_val_if_fail (NAUTILUS_IS_MENU_PROVIDER (provider), NULL);    g_return_val_if_fail (GTK_IS_WIDGET (window), NULL);    if (iface->get_file_items != NULL)    {        return iface->get_file_items (provider, window, files);    }    return NULL;}

/** * gel_ui_widget_disable_drop: * @widget: A #GtkWidget * * Disables DnD functions added by gel_ui_widget_enable_drop on @widget */voidgel_ui_widget_disable_drop(GtkWidget *widget){	g_return_if_fail(GTK_IS_WIDGET(widget));	if (g_object_get_data((GObject *) widget, "gel-ui-dnd-callback") == NULL)	{		g_warning(_("Widget has not been made droppable by GelUI, ignoring."));		return;	}	gtk_drag_dest_unset(widget);	g_object_set_data((GObject *) widget, "gel-ui-dnd-callback",  NULL);	g_object_set_data((GObject *) widget, "gel-ui-dnd-user-data", NULL);	g_signal_handlers_disconnect_by_func(widget, __gel_ui_drag_drop_cb, NULL);	g_signal_handlers_disconnect_by_func(widget, __gel_ui_drag_data_received, NULL);}

voidgdict_show_pref_dialog (GtkWidget         *parent,			const gchar       *title,			GdictSourceLoader *loader){  GtkWidget *dialog;    g_return_if_fail (GTK_IS_WIDGET (parent));  g_return_if_fail (GDICT_IS_SOURCE_LOADER (loader));    if (parent != NULL)    dialog = g_object_get_data (G_OBJECT (parent), "gdict-pref-dialog");  else    dialog = global_dialog;    if (dialog == NULL)    {      dialog = g_object_new (GDICT_TYPE_PREF_DIALOG,                             "source-loader", loader,                             "title", title,                             NULL);            g_object_ref_sink (dialog);            g_signal_connect (dialog, "delete-event",                        G_CALLBACK (gtk_widget_hide_on_delete),                        NULL);            if (parent != NULL && GTK_IS_WINDOW (parent))        {          gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent));          gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);          g_object_set_data_full (G_OBJECT (parent), "gdict-pref-dialog",                                  dialog,                                  g_object_unref);        }      else        global_dialog = dialog;    }  gtk_window_set_screen (GTK_WINDOW (dialog), gtk_widget_get_screen (parent));  gtk_window_present (GTK_WINDOW (dialog));}

static gbooleangb_vim_command_write (GtkWidget      *active_widget,                      const gchar    *command,                      const gchar    *options,                      GError        **error){  g_assert (GTK_IS_WIDGET (active_widget));  if (IDE_IS_EDITOR_PAGE (active_widget))    {      IdeSourceView *source_view = ide_editor_page_get_view (IDE_EDITOR_PAGE (active_widget));      dzl_gtk_widget_action (GTK_WIDGET (source_view), "editor-page", "save", NULL);      return TRUE;    }  else    return gb_vim_set_source_view_error (error);}

voidgo_combo_box_construct (GOComboBox *combo,			GtkWidget *display_widget,			GtkWidget *popdown_container,			GtkWidget *popdown_focus){	GtkWidget *tearable;	GtkWidget *vbox;	g_return_if_fail (IS_GO_COMBO_BOX (combo));	g_return_if_fail (GTK_IS_WIDGET (display_widget));	GTK_BOX (combo)->spacing = 0;	GTK_BOX (combo)->homogeneous = FALSE;	combo->priv->popdown_container = popdown_container;	combo->priv->display_widget = NULL;	vbox = gtk_vbox_new (FALSE, 5);	tearable = gtk_tearoff_menu_item_new ();	g_signal_connect (tearable, "enter-notify-event",			  G_CALLBACK (cb_tearable_enter_leave),			  GINT_TO_POINTER (TRUE));	g_signal_connect (tearable, "leave-notify-event",			  G_CALLBACK (cb_tearable_enter_leave),			  GINT_TO_POINTER (FALSE));	g_signal_connect (tearable, "button-release-event",			  G_CALLBACK (cb_tearable_button_release),			  (gpointer) combo);	gtk_box_pack_start (GTK_BOX (vbox), tearable, FALSE, FALSE, 0);	gtk_box_pack_start (GTK_BOX (vbox), popdown_container, TRUE, TRUE, 0);	combo->priv->tearable = tearable;	g_object_set (tearable, "no-show-all", TRUE, NULL);	go_combo_box_set_tearable (combo, FALSE);	go_combo_box_set_relief (combo, GTK_RELIEF_NORMAL);	go_combo_box_set_display (combo, display_widget);	gtk_container_add (GTK_CONTAINER (combo->priv->frame), vbox);	gtk_widget_show_all (combo->priv->frame);}

GtkWidget *gimp_viewable_dialog_new (GimpViewable *viewable,                          GimpContext  *context,                          const gchar  *title,                          const gchar  *role,                          const gchar  *icon_name,                          const gchar  *desc,                          GtkWidget    *parent,                          GimpHelpFunc  help_func,                          const gchar  *help_id,                          ...){  GimpViewableDialog *dialog;  va_list             args;  g_return_val_if_fail (viewable == NULL || GIMP_IS_VIEWABLE (viewable), NULL);  g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL);  g_return_val_if_fail (title != NULL, NULL);  g_return_val_if_fail (role != NULL, NULL);  g_return_val_if_fail (parent == NULL || GTK_IS_WIDGET (parent), NULL);  if (! viewable)    g_warning ("Use of GimpViewableDialog with a NULL viewable is depecrated!");  dialog = g_object_new (GIMP_TYPE_VIEWABLE_DIALOG,                         "viewable",    viewable,                         "context",     context,                         "title",       title,                         "role",        role,                         "help-func",   help_func,                         "help-id",     help_id,                         "icon-name",   icon_name,                         "description", desc,                         "parent",      parent,                         NULL);  va_start (args, help_id);  gimp_dialog_add_buttons_valist (GIMP_DIALOG (dialog), args);  va_end (args);  return GTK_WIDGET (dialog);}

static GtkWidget *contacts_edit_add_focus_events (GtkWidget *widget, GtkWidget *ebox,	GList *widgets){	if (!ebox) {		GtkWidget *align = gtk_alignment_new (0.5, 0.5, 1, 1);		ebox = gtk_event_box_new ();		gtk_container_add (GTK_CONTAINER (align), widget);		gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, 6, 6);		gtk_container_add (GTK_CONTAINER (ebox), align);		gtk_widget_show (align);		gtk_widget_show (ebox);		gtk_widget_set_name (ebox, gtk_widget_get_name (widget));	}		if (!widget)		return ebox;		if (GTK_IS_CONTAINER (widget) && !GTK_IS_TEXT_VIEW (widget)) {		GList *c, *children =			gtk_container_get_children (GTK_CONTAINER (widget));		for (c = children; c; c = c->next) {			contacts_edit_add_focus_events (GTK_WIDGET (c->data),				ebox, widgets);		}		g_list_free (children);	} else if (GTK_IS_WIDGET (widget)) {			GList *w;		g_signal_connect (G_OBJECT (widget), "focus-in-event",			G_CALLBACK (contacts_edit_focus_in), ebox);		g_signal_connect (G_OBJECT (widget), "focus-out-event",			G_CALLBACK (contacts_edit_focus_out), ebox);		for (w = widgets; w; w = w->next) {			g_signal_connect (G_OBJECT (widget), "focus-in-event",				G_CALLBACK (contacts_edit_focus_in), w->data);			g_signal_connect (G_OBJECT (widget), "focus-out-event",				G_CALLBACK (contacts_edit_focus_out), w->data);		}	}		return ebox;}

/** * gimp_help_connect: * @widget: The widget you want to connect the help accelerator for. Will *          be a #GtkWindow in most cases. * @help_func: The function which will be called if the user presses "F1". * @help_id:   The @help_id which will be passed to @help_func. * @help_data: The @help_data pointer which will be passed to @help_func. * * Note that this function is automatically called by all libgimp dialog * constructors. You only have to call it for windows/dialogs you created * "manually". **/voidgimp_help_connect (GtkWidget    *widget,                   GimpHelpFunc  help_func,                   const gchar  *help_id,                   gpointer      help_data){  static gboolean initialized = FALSE;  g_return_if_fail (GTK_IS_WIDGET (widget));  g_return_if_fail (help_func != NULL);  /*  set up the help signals   */  if (! initialized)    {      GtkBindingSet *binding_set;      binding_set =        gtk_binding_set_by_class (g_type_class_peek (GTK_TYPE_WIDGET));      gtk_binding_entry_add_signal (binding_set, GDK_KEY_F1, 0,                                    "show-help", 1,                                    GTK_TYPE_WIDGET_HELP_TYPE,                                    GIMP_WIDGET_HELP_TYPE_HELP);      gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_F1, 0,                                    "show-help", 1,                                    GTK_TYPE_WIDGET_HELP_TYPE,                                    GIMP_WIDGET_HELP_TYPE_HELP);      initialized = TRUE;    }  gimp_help_set_help_data (widget, NULL, help_id);  g_object_set_data (G_OBJECT (widget), "gimp-help-data", help_data);  g_signal_connect (widget, "show-help",                    G_CALLBACK (gimp_help_callback),                    help_func);  gtk_widget_add_events (widget, GDK_BUTTON_PRESS_MASK);}

static voidpgpug_window_content_pane_switch_page (PgpugContentPane *pane,				       GtkWidget *child,				       guint page_num,				       PgpugWindow *window){     g_return_if_fail (PGPUG_IS_WINDOW (window));     g_return_if_fail (PGPUG_IS_CONTENT_PANE (pane));     g_return_if_fail (GTK_IS_WIDGET (child));     /* remove all detail panes if any */     pgpug_window_detail_pane_clear (window);        PgpugWindowPrivate *priv = window->priv;          PgpugPane *src_pane = g_hash_table_lookup (priv->view_pane_map, child);        g_return_if_fail (PGPUG_IS_PANE (src_pane));     GList *elem, *detail_pane_list = NULL;     g_object_get (src_pane,		   "detail-panes-list", &detail_pane_list,		   NULL);     elem = detail_pane_list;         while (elem != NULL){	  PgpugPane *detail_pane = PGPUG_PANE (elem->data); 	  /* check if pane state is active */	  gboolean is_inactive = g_object_get_data (G_OBJECT (detail_pane), 						    KEY_PGPUG_WINDOW_IS_PANE_INACTIVE) != NULL;	  	  if (!is_inactive)	       pgpug_window_install_pane (window, detail_pane, PGPUG_PANE_DETAIL);	  elem = g_list_next (elem);     }     g_list_free (detail_pane_list);     pgpug_window_rebuild_view_menu (window);     DEBG_MSG ("PgpugWindow: Page has been switched to %d in the content pane", page_num);}

void ucview_info_box_add_action_widget( UCViewInfoBox  *box, GtkWidget *widget, gint response_id ){   ResponseData *rd;   guint signal_id;   g_return_if_fail( IS_UCVIEW_INFO_BOX( box ) );   g_return_if_fail( GTK_IS_WIDGET( widget ) );   rd = get_response_data( widget, TRUE );   rd->response_id = response_id;      if( GTK_IS_BUTTON( widget ) )   {      signal_id = g_signal_lookup( "clicked", GTK_TYPE_BUTTON );   }   else   {      signal_id = GTK_WIDGET_GET_CLASS( widget )->activate_signal;   }      if( signal_id )   {      GClosure *closure;            closure = g_cclosure_new_object( G_CALLBACK( action_widget_activated ), G_OBJECT( box ) );            g_signal_connect_closure_by_id( widget, signal_id, 0, closure, FALSE );   }   else   {      g_warning( "UCViewInfoBox: add_action_widget: Item not activatable" );   }      if( response_id != GTK_RESPONSE_HELP )   {      gtk_box_pack_start( GTK_BOX( box->priv->action_box ), widget, FALSE, FALSE, 12 );   }   else   {      gtk_box_pack_end( GTK_BOX( box->priv->action_box ), widget, FALSE, FALSE, 12 );   }   }

voidgimp_dialog_factory_add_foreign (GimpDialogFactory *factory,                                 const gchar       *identifier,                                 GtkWidget         *dialog){  GimpDialogFactory      *dialog_factory;  GimpDialogFactoryEntry *entry;  g_return_if_fail (GIMP_IS_DIALOG_FACTORY (factory));  g_return_if_fail (identifier != NULL);  g_return_if_fail (GTK_IS_WIDGET (dialog));  g_return_if_fail (GTK_WIDGET_TOPLEVEL (dialog));  dialog_factory = gimp_dialog_factory_from_widget (dialog, &entry);  if (dialog_factory || entry)    {      g_warning ("%s: dialog was created by a GimpDialogFactory",                 G_STRFUNC);      return;    }  entry = gimp_dialog_factory_find_entry (factory, identifier);  if (! entry)    {      g_warning ("%s: no entry registered for /"%s/"",                 G_STRFUNC, identifier);      return;    }  if (entry->new_func)    {      g_warning ("%s: entry for /"%s/" has a constructor (is not foreign)",                 G_STRFUNC, identifier);      return;    }  gimp_dialog_factory_set_widget_data (dialog, factory, entry);  gimp_dialog_factory_add_dialog (factory, dialog);}

/*!  /brief A generic function to returns the data from the representation of  ECU memory. This will call an ECU specific function to do the heavy lifting  /param data is either a GtkWidget pointer or a gconstpointer which contains  name:value associations describng the location to return  /returns the value requested or 0 if error*/G_MODULE_EXPORT gint get_ecu_data(gpointer data){	gint canID = 0;	gint page = 0;	gint offset = 0;	DataSize size = MTX_U08;	gint value = 0 ;	GtkWidget *widget = NULL;	gconstpointer *container = NULL;	Firmware_Details *firmware = NULL;	static gint (*_get_sized_data)(guint8 *, gint, DataSize, gboolean) = NULL;	if (!_get_sized_data)		get_symbol_f("_get_sized_data",(void*)&_get_sized_data);	g_return_val_if_fail(_get_sized_data,0);	firmware = DATA_GET(global_data,"firmware");	/* Sanity checking */	g_return_val_if_fail(data,0);	g_return_val_if_fail(firmware,0);	g_return_val_if_fail(firmware->page_params,0);	g_return_val_if_fail(firmware->page_params[page],0);	g_return_val_if_fail(((offset >= 0 ) && (offset < firmware->page_params[page]->length)),0);	widget = (GtkWidget *)data;	container = (gconstpointer *)data;	if (GTK_IS_WIDGET(widget))	{		canID = (GINT)OBJ_GET(widget,"canID");		page = (GINT)OBJ_GET(widget,"page");		offset = (GINT)OBJ_GET(widget,"offset");		size = (DataSize)OBJ_GET(widget,"size");	}	else	{		canID = (GINT)DATA_GET(container,"canID");		page = (GINT)DATA_GET(container,"page");		offset = (GINT)DATA_GET(container,"offset");		size = (DataSize)DATA_GET(container,"size");	}	return _get_sized_data(firmware->ecu_data[page],offset,size,firmware->bigendian);}

static gbooleandma_data_view_goto_key_press_event (GtkWidget *widget,									GdkEventKey *event,									DmaDataView *view){	g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);	g_return_val_if_fail (IS_DMA_DATA_VIEW (view), FALSE);	/* Close window */	if (event->keyval == GDK_KEY_Escape ||		event->keyval == GDK_KEY_Tab ||		event->keyval == GDK_KEY_KP_Tab ||		event->keyval == GDK_KEY_ISO_Left_Tab)    {		dma_data_view_goto_window_hide (view);		return TRUE;    }	/* Goto to address and close window */	if (event->keyval == GDK_KEY_Return ||		event->keyval == GDK_KEY_ISO_Enter ||		event->keyval == GDK_KEY_KP_Enter)	{		gulong adr;		const gchar *text;		gchar *end;				text = gtk_entry_get_text (GTK_ENTRY (view->goto_entry));		adr = strtoul (text, &end, 0);				if ((*text != '/0') && (*end == '/0'))		{			/* Valid input goto to address */			gtk_adjustment_set_value (view->buffer_range, adr);		}				dma_data_view_goto_window_hide (view);		return TRUE;	}		return FALSE;}