static void adapt_form_widget (GdauiProviderSpecEditor *spec) { /* destroy any previous widget */ if (spec->priv->form) { gtk_container_foreach (GTK_CONTAINER (spec), (GtkCallback) gtk_widget_destroy, NULL); spec->priv->form = NULL; } spec->priv->type = NO_PROVIDER; if (!spec->priv->provider) return; /* fetch DSN parameters */ GdaProviderInfo *pinfo; pinfo = gda_config_get_provider_info (spec->priv->provider); if (!pinfo) { g_warning (_("Unknown provider '%s'"), spec->priv->provider); return; } if (!pinfo->dsn_params) { g_warning (_("Provider '%s' does not report the required parameters for DSN"), spec->priv->provider); return; } /* create new widget */ GdaSet *dset; dset = gda_set_copy (pinfo->dsn_params); if (dset) { GtkWidget *wid; spec->priv->type = PROVIDER_FORM; wid = gdaui_basic_form_new (dset); g_object_set ((GObject*) wid, "show-actions", FALSE, NULL); g_object_unref (dset); spec->priv->form = wid; if (spec->priv->labels_size_group) gdaui_basic_form_add_to_size_group (GDAUI_BASIC_FORM (spec->priv->form), spec->priv->labels_size_group, GDAUI_BASIC_FORM_LABELS); if (spec->priv->entries_size_group) gdaui_basic_form_add_to_size_group (GDAUI_BASIC_FORM (spec->priv->form), spec->priv->entries_size_group, GDAUI_BASIC_FORM_ENTRIES); update_form_contents (spec); g_signal_connect (G_OBJECT (wid), "holder-changed", G_CALLBACK (dsn_form_changed), spec); gtk_widget_show (wid); gtk_container_add (GTK_CONTAINER (spec), wid); } }
static void update_operations (NautilusToolbar *self) { GList *progress_infos; GList *l; GtkWidget *progress; gboolean should_show_progress_button = FALSE; gtk_container_foreach (GTK_CONTAINER (self->priv->operations_container), (GtkCallback) gtk_widget_destroy, NULL); disconnect_progress_infos (self); progress_infos = get_filtered_progress_infos (self); for (l = progress_infos; l != NULL; l = l->next) { should_show_progress_button = should_show_progress_button || should_show_progress_info (l->data); g_signal_connect_swapped (l->data, "finished", G_CALLBACK (on_progress_info_finished), self); g_signal_connect_swapped (l->data, "cancelled", G_CALLBACK (on_progress_info_cancelled), self); g_signal_connect_swapped (l->data, "progress-changed", G_CALLBACK (on_progress_info_progress_changed), self); progress = nautilus_progress_info_widget_new (l->data); gtk_box_pack_start (GTK_BOX (self->priv->operations_container), progress, FALSE, FALSE, 0); } g_list_free (progress_infos); /* Either we are already showing the button, so keep showing it until the user * toggle it to hide the operations popover, or, if we want now to show it, * we have to have at least one operation that its total stimated time * is longer than OPERATION_MINIMUM_TIME seconds, or if we failed to get * a correct stimated time and it's around OPERATION_MINIMUM_TIME, * showing the button for just for a moment because now we realized the * estimated time is longer than a OPERATION_MINIMUM_TIME is odd, so show * it only if the remaining time is bigger than again OPERATION_MINIMUM_TIME. */ if (should_show_progress_button && !gtk_revealer_get_reveal_child (GTK_REVEALER (self->priv->operations_revealer))) { add_operations_button_attention_style (self); gtk_revealer_set_reveal_child (GTK_REVEALER (self->priv->operations_revealer), TRUE); gtk_widget_queue_draw (self->priv->operations_icon); } }
static void update_child_count (TrayData *data) { guint n_children = 0; char text[64]; if (!gtk_widget_get_realized (GTK_WIDGET (data))) return; gtk_container_foreach (GTK_CONTAINER (data->box), (GtkCallback) do_add, &n_children); g_snprintf (text, sizeof (text), "%u icons", n_children); gtk_label_set_text (data->count_label, text); }
static void update_sidebar (GcalYearView *year_view) { GcalYearViewPrivate *priv = year_view->priv; GtkWidget *child_widget; GList *events, *l; GList **days_widgets_array; gint i, days_span; update_selected_dates_from_button_data (year_view); gtk_container_foreach (GTK_CONTAINER (priv->events_sidebar), (GtkCallback) gtk_widget_destroy, NULL); days_span = icaltime_day_of_year(*(priv->end_selected_date)) - icaltime_day_of_year(*(priv->start_selected_date)) + 1; days_widgets_array = g_new0 (GList*, days_span); events = gcal_manager_get_events (priv->manager, priv->start_selected_date, priv->end_selected_date); if (events == NULL) { days_span = 0; update_no_events_page (year_view); gtk_stack_set_visible_child_name (GTK_STACK (priv->navigator_stack), "no-events"); } else { gtk_stack_set_visible_child_name (GTK_STACK (priv->navigator_stack), "events-list"); } for (l = events; l != NULL; l = g_list_next (l)) add_event_to_day_array (year_view, l->data, days_widgets_array, days_span); for (i = 0; i < days_span; i++) { GList *current_day = days_widgets_array[i]; for (l = current_day; l != NULL; l = g_list_next (l)) { child_widget = l->data; gtk_widget_show (child_widget); g_signal_connect (child_widget, "activate", G_CALLBACK (event_activated), year_view); g_object_set_data (G_OBJECT (child_widget), "shift", GINT_TO_POINTER (i)); gtk_container_add (GTK_CONTAINER (priv->events_sidebar), child_widget); } g_list_free (current_day); } g_free (days_widgets_array); g_list_free_full (events, g_free); }
static void remove_early_perspectives (IdeWorkbench *self) { g_assert (IDE_IS_WORKBENCH (self)); if (self->early_perspectives_removed) return; gtk_container_foreach (GTK_CONTAINER (self->perspectives_stack), do_remove_early_perspectives, NULL); self->early_perspectives_removed = TRUE; }
static void SetPage(int32_t n) { if (!gtkenabled || !stwidgets.startwin) return; mode = n; gtk_notebook_set_current_page(GTK_NOTEBOOK(stwidgets.tabs), n); // each control in the config page vertical layout plus the start button should be made (in)sensitive if (n == TAB_CONFIG) n = TRUE; else n = FALSE; gtk_widget_set_sensitive(stwidgets.startbutton, n); gtk_container_foreach(GTK_CONTAINER(stwidgets.configtlayout), (GtkCallback)gtk_widget_set_sensitive, (gpointer)&n); }
static void set_font (GtkWidget *w, gpointer data) { PangoFontDescription *font_desc = data; GtkRcStyle *style = gtk_widget_get_modifier_style (w); pango_font_description_free (style->font_desc); style->font_desc = pango_font_description_copy (font_desc); gtk_widget_modify_style (w, style); if ( GTK_IS_CONTAINER (w)) gtk_container_foreach (GTK_CONTAINER (w), set_font, font_desc); }
/*! \brief populate_master() stores a pointer to all of the glade loaded widgets into a master hashtable so that it can be recalled by name anywhere in the program. \param widget is the pointer to Widget \param user_data is the pointer to ConfigFile structure */ G_MODULE_EXPORT void populate_master(GtkWidget *widget, gpointer user_data ) { gchar *name = NULL; gchar *fullname = NULL; gchar *prefix = NULL; GHashTable *dynamic_widgets = NULL; ConfigFile *cfg = (ConfigFile *) user_data; /*! Populates a big master hashtable of all dynamic widgets so that various functions can do a lookup for the widgets name and get it's GtkWidget * for manipulation. We do NOT insert the topframe widgets from the XML tree as if more than 1 tab loads there will be a clash, and there's no need to store the top frame widget anyways... */ if (GTK_IS_CONTAINER(widget)) gtk_container_foreach(GTK_CONTAINER(widget),populate_master,user_data); if (!cfg_read_string(cfg,"global","id_prefix",&prefix)) prefix = g_strdup(""); name = (char *)glade_get_widget_name(widget); /*printf("name of widget stored is %s\n",name);*/ if (name == NULL) { g_free(prefix); return; } if (g_strrstr((gchar *)name,"topframe")) { g_free(prefix); return; } dynamic_widgets = DATA_GET(global_data,"dynamic_widgets"); if(!dynamic_widgets) { dynamic_widgets = g_hash_table_new_full(g_str_hash,g_str_equal,g_free,NULL); DATA_SET_FULL(global_data,"dynamic_widgets",dynamic_widgets,g_hash_table_destroy); } fullname = g_strdup_printf("%s%s",prefix,name); OBJ_SET_FULL(widget,"fullname",g_strdup(fullname),g_free); OBJ_SET(widget,"last_value",GINT_TO_POINTER(-G_MAXINT)); if (!g_hash_table_lookup(dynamic_widgets,fullname)) g_hash_table_insert(dynamic_widgets,g_strdup(fullname),(gpointer)widget); else MTXDBG(CRITICAL,_("Key %s for widget %s from file %s already exists in master table\n"),name,fullname,cfg->filename); g_free(prefix); g_free(fullname); }
void bar_set_fd(GtkWidget *bar, FileData *fd) { BarData *bd; bd = g_object_get_data(G_OBJECT(bar), "bar_data"); if (!bd) return; file_data_unref(bd->fd); bd->fd = file_data_ref(fd); gtk_container_foreach(GTK_CONTAINER(bd->vbox), bar_pane_set_fd_cb, fd); gtk_label_set_text(GTK_LABEL(bd->label_file_name), (bd->fd) ? bd->fd->name : ""); }
static void gtk_shortcuts_window_add_section (GtkShortcutsWindow *self, GtkShortcutsSection *section) { GtkShortcutsWindowPrivate *priv = gtk_shortcuts_window_get_instance_private (self); GtkListBoxRow *row; gchar *title; gchar *name; const gchar *visible_section; GtkWidget *label; gtk_container_foreach (GTK_CONTAINER (section), gtk_shortcuts_window_add_search_item, self); g_object_get (section, "section-name", &name, "title", &title, NULL); g_signal_connect (section, "notify", G_CALLBACK (section_notify_cb), self); if (name == NULL) name = g_strdup ("shortcuts"); gtk_stack_add_titled (priv->stack, GTK_WIDGET (section), name, title); visible_section = gtk_stack_get_visible_child_name (priv->stack); if (strcmp (visible_section, "internal-search") == 0 || (priv->initial_section && strcmp (priv->initial_section, visible_section) == 0)) gtk_stack_set_visible_child (priv->stack, GTK_WIDGET (section)); row = g_object_new (GTK_TYPE_LIST_BOX_ROW, "visible", TRUE, NULL); g_object_set_data (G_OBJECT (row), "gtk-shortcuts-section", section); label = g_object_new (GTK_TYPE_LABEL, "margin", 6, "label", title, "xalign", 0.5f, "visible", TRUE, NULL); g_object_set_data (G_OBJECT (section), "gtk-shortcuts-title", label); gtk_container_add (GTK_CONTAINER (row), GTK_WIDGET (label)); gtk_container_add (GTK_CONTAINER (priv->list_box), GTK_WIDGET (row)); update_title_stack (self); g_free (name); g_free (title); }
static void change_orient(struct app_t *app, int is_vert) { if (is_vert != app->is_vert) { GtkWidget *from, *to, *parent; app->is_vert = is_vert; from = app->pack; if (is_vert) to = gtk_vbox_new(FALSE, 0); else to = gtk_hbox_new(FALSE, 0); parent = gtk_widget_get_parent(from); gtk_container_foreach(GTK_CONTAINER(from), reparent_iter, to); gtk_container_foreach(GTK_CONTAINER(to), setvert_iter, GINT_TO_POINTER(is_vert)); app->pack = to; gtk_box_pack_start(GTK_BOX(parent), to, TRUE, TRUE, 0); gtk_widget_destroy(from); gtk_widget_show_all(to); } }
static void _item_active_changed (GtkWidget *item, GParamSpec *pspec, GtkWidget *list) { CarrickListPrivate *priv = LIST_PRIVATE (list); if (carrick_service_item_get_active (CARRICK_SERVICE_ITEM (item))) { gtk_container_foreach (GTK_CONTAINER (priv->box), (GtkCallback) _list_collapse_inactive_items, item); _set_active_item (CARRICK_LIST (list), item); } }
GtkSizeGroup * gtk_utils_align_left_widgets (GtkContainer *container, GtkSizeGroup *size_group) { g_return_val_if_fail (GTK_IS_CONTAINER (container), NULL); g_return_val_if_fail (!size_group || GTK_IS_SIZE_GROUP (size_group), NULL); if (!size_group) size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); gtk_container_foreach (container, (GtkCallback) do_align_left_widgets, size_group); return size_group; }
/* Find throbber of view or browser */ static void _interface_tweaks_find_view_throbber_callback(GtkWidget *inWidget, gpointer inUserData) { g_return_if_fail(GTK_IS_WIDGET(inWidget)); if(KATZE_IS_THROBBER(inWidget)) { KatzeThrobber **throbber=(KatzeThrobber**)inUserData; if(throbber) *throbber=KATZE_THROBBER(inWidget); } else if(GTK_IS_CONTAINER(inWidget)) { gtk_container_foreach(GTK_CONTAINER(inWidget), _interface_tweaks_find_view_throbber_callback, inUserData); } }
/* Find close button of view */ static void _interface_tweaks_find_view_close_button_callback(GtkWidget *inWidget, gpointer inUserData) { g_return_if_fail(GTK_IS_WIDGET(inWidget)); if(g_strcmp0(gtk_widget_get_name(inWidget), "midori-close-button")==0) { GtkWidget **closeButton=(GtkWidget**)inUserData; if(closeButton) *closeButton=GTK_WIDGET(inWidget); } else if(GTK_IS_CONTAINER(inWidget)) { gtk_container_foreach(GTK_CONTAINER(inWidget), _interface_tweaks_find_view_close_button_callback, inUserData); } }
static void _interface_tweaks_find_browser_locationbar_callback(GtkWidget *inWidget, gpointer inUserData) { g_return_if_fail(GTK_IS_WIDGET(inWidget)); if(GTK_IS_TOOL_ITEM(inWidget)) { GtkAction *action; action=gtk_activatable_get_related_action(GTK_ACTIVATABLE(inWidget)); if(g_strcmp0(gtk_action_get_name(action), "Location")==0) { InterfaceTweaksLocationbarLookup **item=(InterfaceTweaksLocationbarLookup**)inUserData; if(item) (*item)->action=action; gtk_container_foreach(GTK_CONTAINER(inWidget), _interface_tweaks_find_browser_locationbar_entry_callback, inUserData); } else if(g_strcmp0(gtk_action_get_name(action), "LocationSearch")==0) { InterfaceTweaksLocationbarLookup **item=(InterfaceTweaksLocationbarLookup**)inUserData; GtkWidget *locationChild; if(item) (*item)->action=action; locationChild=midori_paned_action_get_child_by_name(MIDORI_PANED_ACTION(action), "Location"); if(locationChild) { gtk_container_foreach(GTK_CONTAINER(locationChild), _interface_tweaks_find_browser_locationbar_entry_callback, inUserData); } } } else if(GTK_IS_CONTAINER(inWidget)) { gtk_container_foreach(GTK_CONTAINER(inWidget), _interface_tweaks_find_browser_locationbar_callback, inUserData); } }
/* Find locationbar of browser (and entry of locationbar) */ static void _interface_tweaks_find_browser_locationbar_entry_callback(GtkWidget *inWidget, gpointer inUserData) { g_return_if_fail(GTK_IS_WIDGET(inWidget)); if(GTK_IS_ENTRY(inWidget)) { InterfaceTweaksLocationbarLookup **item=(InterfaceTweaksLocationbarLookup**)inUserData; if(item) (*item)->widget=inWidget; } else if(GTK_IS_CONTAINER(inWidget)) { gtk_container_foreach(GTK_CONTAINER(inWidget), _interface_tweaks_find_browser_locationbar_entry_callback, inUserData); } }
/** * gel_ui_container_replace_children: * @container: A #GtkContainer * @widget: (transfer full): A #GtkWidget * * Removes all children from @container using gel_ui_container_clear() and * then packs @widget into @container */ void gel_ui_container_replace_children(GtkContainer *container, GtkWidget *widget) { g_return_if_fail(GTK_IS_CONTAINER(container)); g_return_if_fail(GTK_IS_WIDGET(widget)); gtk_container_foreach(container, (GtkCallback) gtk_widget_destroy, NULL); if (GTK_IS_BOX(container)) gtk_box_pack_start(GTK_BOX(container), widget, TRUE, TRUE, 0); else if (GTK_IS_GRID(container)) { gtk_grid_attach(GTK_GRID(container), widget, 0, 0, 1, 1); g_object_set((GObject *) widget, "hexpand", TRUE, "vexpand", TRUE, NULL); } }
static void clear_search(dt_lib_location_t *lib) { g_free(lib->response); lib->response = NULL; lib->response_size = 0; lib->selected_location = NULL; g_list_free_full(lib->places, (GDestroyNotify)free_location); lib->places = NULL; gtk_container_foreach(GTK_CONTAINER(lib->result), (GtkCallback)gtk_widget_destroy, NULL); g_list_free_full(lib->callback_params, free); lib->callback_params = NULL; _clear_markers(lib); }
/* updates the legend */ static void update_legend() { GtkWidget *prot_table; /* first, check if there are expired protocols */ prot_table = glade_xml_get_widget (appdata.xml, "prot_table"); if (!prot_table) return; gtk_container_foreach(GTK_CONTAINER(prot_table), (GtkCallback)purge_expired_legend_protocol, NULL); /* then search for new protocols */ check_new_protocol(prot_table, protocol_summary_stack()); }
void ide_frame_set_placeholder (IdeFrame *self, GtkWidget *placeholder) { IdeFramePrivate *priv = ide_frame_get_instance_private (self); g_return_if_fail (IDE_IS_FRAME (self)); g_return_if_fail (!placeholder || GTK_IS_WIDGET (placeholder)); gtk_container_foreach (GTK_CONTAINER (priv->empty_placeholder), (GtkCallback) gtk_widget_destroy, NULL); if (placeholder != NULL) gtk_container_add (GTK_CONTAINER (priv->empty_placeholder), placeholder); }
static void photos_import_dialog_collections_popover_search_changed (PhotosImportDialog *self) { guint16 text_length; gtk_container_foreach (GTK_CONTAINER (self->collections_popover_grid), (GtkCallback) gtk_widget_destroy, NULL); text_length = gtk_entry_get_text_length (GTK_ENTRY (self->collections_popover_search_entry)); if (text_length == 0) { GList *l; for (l = self->recent_collections; l != NULL; l = l->next) { GtkWidget *collection_button; PhotosBaseItem *collection = PHOTOS_BASE_ITEM (l->data); collection_button = photos_import_dialog_create_collection_button (collection); gtk_container_add (GTK_CONTAINER (self->collections_popover_grid), collection_button); gtk_widget_show_all (collection_button); } } else { g_autoptr (GArray) matches = NULL; const gchar *text; guint i; text = gtk_entry_get_text (GTK_ENTRY (self->collections_popover_search_entry)); matches = dzl_fuzzy_mutable_index_match (self->index, text, MAX_MATCHES); for (i = 0; i < matches->len; i++) { const DzlFuzzyMutableIndexMatch *match; GtkWidget *collection_button; PhotosBaseItem *collection; match = &g_array_index (matches, DzlFuzzyMutableIndexMatch, i); collection = PHOTOS_BASE_ITEM (match->value); collection_button = photos_import_dialog_create_collection_button (collection); gtk_container_add (GTK_CONTAINER (self->collections_popover_grid), collection_button); gtk_widget_show_all (collection_button); } g_return_if_fail (matches->len <= MAX_MATCHES); } }
/** * gedit_notebook_set_close_buttons_sensitive: * @nb: a #GeditNotebook * @sensitive: %TRUE to make the buttons sensitive * * Sets whether the close buttons in the tabs of @nb are sensitive. */ void gedit_notebook_set_close_buttons_sensitive (GeditNotebook *nb, gboolean sensitive) { g_return_if_fail (GEDIT_IS_NOTEBOOK (nb)); sensitive = (sensitive != FALSE); if (sensitive == nb->priv->close_buttons_sensitive) return; nb->priv->close_buttons_sensitive = sensitive; gtk_container_foreach (GTK_CONTAINER (nb), (GtkCallback)set_close_buttons_sensitivity, nb); }
static void _lib_history_change_callback(gpointer instance, gpointer user_data) { dt_lib_module_t *self = (dt_lib_module_t *)user_data; dt_lib_history_t *d = (dt_lib_history_t *)self->data; /* first destroy all buttons in list */ gtk_container_foreach(GTK_CONTAINER(d->history_box), (GtkCallback)gtk_widget_destroy, 0); /* add default which always should be */ int num = -1; gtk_box_pack_start(GTK_BOX(d->history_box), _lib_history_create_button(self, num, _("original"), FALSE, darktable.develop->history_end == 0), TRUE, TRUE, 0); num++; /* lock history mutex */ dt_pthread_mutex_lock(&darktable.develop->history_mutex); /* iterate over history items and add them to list*/ GList *history = g_list_first(darktable.develop->history); while(history) { dt_dev_history_item_t *hitem = (dt_dev_history_item_t *)(history->data); gchar *label; if(!hitem->multi_name[0] || strcmp(hitem->multi_name, "0") == 0) label = g_strdup_printf("%s", hitem->module->name()); else label = g_strdup_printf("%s %s", hitem->module->name(), hitem->multi_name); gboolean selected = (num == darktable.develop->history_end - 1); GtkWidget *widget = _lib_history_create_button(self, num, label, hitem->enabled, selected); g_free(label); gtk_box_pack_start(GTK_BOX(d->history_box), widget, TRUE, TRUE, 0); gtk_box_reorder_child(GTK_BOX(d->history_box), widget, 0); num++; history = g_list_next(history); } /* show all widgets */ gtk_widget_show_all(d->history_box); dt_pthread_mutex_unlock(&darktable.develop->history_mutex); }
// If you should ever need to change the font for the running application.. // Ugly but effective. void change_font(GtkWidget *widget, gpointer data) { PangoFontDescription *font_desc; gchar *font = (gchar*)data; const gchar *name; font_desc = pango_font_description_from_string(font); if (font_desc == NULL) exit(1); gtk_widget_modify_font(widget, font_desc); name = ghb_get_setting_key(widget); g_debug("changing font for widget %s\n", name); if (GTK_IS_CONTAINER(widget)) { gtk_container_foreach((GtkContainer*)widget, change_font, data); } }
/** * set toolbar logical -> physical; physically visible toolbar buttons are made * to correspond to the logically stored schema in terms of location * visibility etc */ void nsgtk_toolbar_set_physical(nsgtk_scaffolding *g) { int i; struct nsgtk_theme *theme = nsgtk_theme_load(GTK_ICON_SIZE_LARGE_TOOLBAR); if (theme == NULL) { warn_user(messages_get("NoMemory"), 0); return; } /* simplest is to clear the toolbar then reload it from memory */ gtk_container_foreach(GTK_CONTAINER(nsgtk_scaffolding_toolbar(g)), nsgtk_toolbar_clear_toolbar, g); for (i = BACK_BUTTON; i < PLACEHOLDER_BUTTON; i++) nsgtk_toolbar_add_item_to_toolbar(g, i, theme); gtk_widget_show_all(GTK_WIDGET(nsgtk_scaffolding_toolbar(g))); free(theme); }
/* Remove a menu logically */ void EvalCcRqDELETEMENU (CrossCallInfo *pcci) /* HMENU, HITEM; no result. */ { GtkWidget *menu, *menu_item; printf("EvalCcRqDELETEMENU\n"); menu = GTK_WIDGET(pcci->p1); menu_item = GTK_WIDGET(pcci->p2); gtk_container_foreach(GTK_CONTAINER(menu), find_item_callback, (gpointer) &menu_item); if (menu_item != GTK_WIDGET(pcci->p2)) { gtk_menu_item_remove_submenu(GTK_MENU_ITEM(menu_item)); gtk_widget_destroy(menu_item); } MakeReturn0Cci (pcci); }
void EvalCcRqMENUENABLE (CrossCallInfo *pcci) /* parent, zero based position of menu, onoff; no result. */ { GtkWidget *parent_menu, *sub_menu; printf("EvalCcRqMENUENABLE\n"); gint index = pcci->p2; if (pcci->p1 && GTK_IS_CONTAINER(pcci->p1)) { printf("We have a container. Checking the widget.\n"); parent_menu = GTK_WIDGET(pcci->p1); gtk_container_foreach(GTK_CONTAINER(parent_menu), pcci->p3 ? enable_menu_callback : disable_menu_callback, (gpointer) (&index)); } MakeReturn0Cci (pcci); }
void plugin_menu_remove (int id, MenuFunc func) { if (menus[id]) gtk_container_foreach ((GtkContainer *) menus[id], (GtkCallback) remove_cb, (void *) func); GList * next; for (GList * node = items[id]; node; node = next) { next = node->next; if (((struct Item *) node->data)->func == func) { g_slice_free (struct Item, node->data); items[id] = g_list_delete_link (items[id], node); } }
/** * ide_workbench_views_foreach: * @self: An #IdeWorkbench. * @callback: (scope call): The callback to execute * @user_data: user data for @callback. * * Executes @callback for every #IdeLayoutView across all perspectives. */ void ide_workbench_views_foreach (IdeWorkbench *self, GtkCallback callback, gpointer user_data) { struct { GtkCallback callback; gpointer user_data; } closure = { callback, user_data }; g_return_if_fail (IDE_IS_WORKBENCH (self)); g_return_if_fail (callback != NULL); gtk_container_foreach (GTK_CONTAINER (self->perspectives_stack), ide_workbench_views_foreach_cb, &closure); }