static void _cogl_clip_stack_restore_real (CoglClipState *clip_state) { CoglHandle stack; g_return_if_fail (clip_state->stacks != NULL); stack = clip_state->stacks->data; _cogl_clip_stack_unref (stack); /* Revert to an old stack */ clip_state->stacks = g_slist_delete_link (clip_state->stacks, clip_state->stacks); }
/** * nice_component_detach_socket: * @component: a #NiceComponent * @socket: the socket to detach the source for * * Detach the #GSource for the single specified @socket. It also closes it * and frees it! * * If the @socket doesn’t exist in this @component, do nothing. */ static void nice_component_detach_socket (NiceComponent *component, NiceSocket *nicesock) { GSList *l; SocketSource *socket_source; nice_debug ("Detach socket %p.", nicesock); /* Remove the socket from various lists. */ for (l = component->incoming_checks; l != NULL;) { IncomingCheck *icheck = l->data; GSList *next = l->next; if (icheck->local_socket == nicesock) { component->incoming_checks = g_slist_delete_link (component->incoming_checks, l); incoming_check_free (icheck); } l = next; } /* Find the SocketSource for the socket. */ l = g_slist_find_custom (component->socket_sources, nicesock, _find_socket_source); if (l == NULL) return; /* Detach the source. */ socket_source = l->data; component->socket_sources = g_slist_delete_link (component->socket_sources, l); component->socket_sources_age++; socket_source_detach (socket_source); socket_source_free (socket_source); }
/** * nm_setting_ip4_config_remove_route: * @setting: the #NMSettingIP4Config * @i: index number of the route * * Removes the route at index @i. **/ void nm_setting_ip4_config_remove_route (NMSettingIP4Config *setting, guint32 i) { NMSettingIP4ConfigPrivate *priv; GSList *elt; g_return_if_fail (NM_IS_SETTING_IP4_CONFIG (setting)); priv = NM_SETTING_IP4_CONFIG_GET_PRIVATE (setting); elt = g_slist_nth (priv->routes, i); g_return_if_fail (elt != NULL); nm_ip4_route_unref ((NMIP4Route *) elt->data); priv->routes = g_slist_delete_link (priv->routes, elt); }
void nm_setting_ip6_config_remove_dns_search (NMSettingIP6Config *setting, guint32 i) { NMSettingIP6ConfigPrivate *priv; GSList *elt; g_return_if_fail (NM_IS_SETTING_IP6_CONFIG (setting)); priv = NM_SETTING_IP6_CONFIG_GET_PRIVATE (setting); elt = g_slist_nth (priv->dns_search, i); g_return_if_fail (elt != NULL); g_free (elt->data); priv->dns_search = g_slist_delete_link (priv->dns_search, elt); }
void xmpp_del_feature(const char *xmlns) { GSList *feature = xmpp_additional_features; while (feature) { if (!strcmp(feature->data, xmlns)) { ver = NULL; ver_notavail = NULL; g_free(feature->data); xmpp_additional_features = g_slist_delete_link(xmpp_additional_features, feature); return; } feature = g_slist_next(feature); } }
void nm_auth_changed_func_unregister (GDestroyNotify callback, gpointer callback_data) { GSList *iter; for (iter = funcs; iter; iter = g_slist_next (iter)) { PkChangedInfo *info = iter->data; if ((callback == info->changed_callback) && (callback_data == info->changed_data)) { g_free (info); funcs = g_slist_delete_link (funcs, iter); break; } } }
/** * nm_setting_connection_remove_secondary: * @setting: the #NMSettingConnection * @idx: index number of the secondary connection UUID * * Removes the secondary coonnection UUID at index @idx. **/ void nm_setting_connection_remove_secondary (NMSettingConnection *setting, guint32 idx) { NMSettingConnectionPrivate *priv; GSList *elt; g_return_if_fail (NM_IS_SETTING_CONNECTION (setting)); priv = NM_SETTING_CONNECTION_GET_PRIVATE (setting); elt = g_slist_nth (priv->secondaries, idx); g_return_if_fail (elt != NULL); g_free (elt->data); priv->secondaries = g_slist_delete_link (priv->secondaries, elt); }
/** * nm_setting_ip6_config_remove_address: * @setting: the #NMSettingIP6Config * @i: index number of the address to remove * * Removes the address at index @i. **/ void nm_setting_ip6_config_remove_address (NMSettingIP6Config *setting, guint32 i) { NMSettingIP6ConfigPrivate *priv; GSList *elt; g_return_if_fail (NM_IS_SETTING_IP6_CONFIG (setting)); priv = NM_SETTING_IP6_CONFIG_GET_PRIVATE (setting); elt = g_slist_nth (priv->addresses, i); g_return_if_fail (elt != NULL); nm_ip6_address_unref ((NMIP6Address *) elt->data); priv->addresses = g_slist_delete_link (priv->addresses, elt); }
static inline void* queued_dsmesock_(unsigned type, const char* name) { queued_msg_t* container = 0; dsmemsg_generic_t* msg = 0; assert(dsmesock_broadcasts); container = dsmesock_broadcasts->data; msg = container->data; assert(msg->type_ == type); free(container); dsmesock_broadcasts = g_slist_delete_link(dsmesock_broadcasts, dsmesock_broadcasts); return msg; }
/** * nm_setting_wired_remove_mac_blacklist_item: * @setting: the #NMSettingWired * @idx: index number of the MAC address * * Removes the MAC address at index @idx from the blacklist. * * Since: 0.9.10 **/ void nm_setting_wired_remove_mac_blacklist_item (NMSettingWired *setting, guint32 idx) { NMSettingWiredPrivate *priv; GSList *elt; g_return_if_fail (NM_IS_SETTING_WIRED (setting)); priv = NM_SETTING_WIRED_GET_PRIVATE (setting); elt = g_slist_nth (priv->mac_address_blacklist, idx); g_return_if_fail (elt != NULL); g_free (elt->data); priv->mac_address_blacklist = g_slist_delete_link (priv->mac_address_blacklist, elt); }
void _cogl_xlib_remove_filter (CoglXlibFilterFunc func, gpointer data) { GSList *l, *prev = NULL; _COGL_GET_CONTEXT (ctx, NO_RETVAL); for (l = ctx->winsys.event_filters; l; prev = l, l = l->next) { CoglXlibFilterClosure *closure = l->data; if (closure->func == func && closure->data == data) { g_slice_free (CoglXlibFilterClosure, closure); if (prev) prev->next = g_slist_delete_link (prev->next, l); else ctx->winsys.event_filters = g_slist_delete_link (ctx->winsys.event_filters, l); break; } } }
static void gst_multi_file_sink_ensure_max_files (GstMultiFileSink * multifilesink) { char *filename; while (multifilesink->max_files && multifilesink->n_files >= multifilesink->max_files) { filename = multifilesink->files->data; g_remove (filename); g_free (filename); multifilesink->files = g_slist_delete_link (multifilesink->files, multifilesink->files); multifilesink->n_files -= 1; } }
static void bonjour_bytestreams_listen(int sock, gpointer data) { PurpleXfer *xfer = data; XepXfer *xf; XepIq *iq; xmlnode *query, *streamhost; gchar *port; GSList *local_ips; BonjourData *bd; purple_debug_info("bonjour", "Bonjour-bytestreams-listen. sock=%d.\n", sock); if (sock < 0 || xfer == NULL) { /*purple_xfer_cancel_local(xfer);*/ return; } xfer->watcher = purple_input_add(sock, PURPLE_INPUT_READ, bonjour_sock5_request_cb, xfer); xf = (XepXfer*)xfer->data; xf->listen_data = NULL; bd = xf->data; iq = xep_iq_new(bd, XEP_IQ_SET, xfer->who, bonjour_get_jid(bd->jabber_data->account), xf->sid); query = xmlnode_new_child(iq->node, "query"); xmlnode_set_namespace(query, "http://jabber.org/protocol/bytestreams"); xmlnode_set_attrib(query, "sid", xf->sid); xmlnode_set_attrib(query, "mode", "tcp"); xfer->local_port = purple_network_get_port_from_fd(sock); local_ips = bonjour_jabber_get_local_ips(sock); port = g_strdup_printf("%hu", (guint16)purple_xfer_get_local_port(xfer)); while(local_ips) { streamhost = xmlnode_new_child(query, "streamhost"); xmlnode_set_attrib(streamhost, "jid", xf->sid); xmlnode_set_attrib(streamhost, "host", local_ips->data); xmlnode_set_attrib(streamhost, "port", port); g_free(local_ips->data); local_ips = g_slist_delete_link(local_ips, local_ips); } g_free(port); xep_iq_send_and_free(iq); }
/** * na_core_utils_slist_remove_utf8: * @slist: the #GSList to be updated. * @text: the string to be removed. * * Removes from the @slist the item which has a string which is equal to * @text. * * Returns: the new @slist start position. * * Since: 2.30 */ GSList * na_core_utils_slist_remove_utf8( GSList *slist, const gchar *text ) { GSList *is; for( is = slist ; is ; is = is->next ){ const gchar *istr = ( const gchar * ) is->data; if( !na_core_utils_str_collate( text, istr )){ g_free( is->data ); slist = g_slist_delete_link( slist, is ); break; } } return( slist ); }
/** * nm_setting_connection_remove_permission: * @setting: the #NMSettingConnection * @idx: the zero-based index of the permission to remove * * Removes the permission at index @idx from the connection. */ void nm_setting_connection_remove_permission (NMSettingConnection *setting, guint32 idx) { NMSettingConnectionPrivate *priv; GSList *iter; g_return_if_fail (NM_IS_SETTING_CONNECTION (setting)); priv = NM_SETTING_CONNECTION_GET_PRIVATE (setting); iter = g_slist_nth (priv->permissions, idx); g_return_if_fail (iter != NULL); permission_free ((Permission *) iter->data); priv->permissions = g_slist_delete_link (priv->permissions, iter); }
void free_new_node(struct new_node_event_t *node_event) { GSList *cursor; cursor = node_event->resources; while (cursor != NULL) { struct resource_info_t *resource = (struct resource_info_t*)cursor->data; if (resource->has_value) free((char*)resource->value); free(resource); resource = NULL; cursor = g_slist_delete_link(cursor, cursor); } free(node_event); }
void refresh_prune_socket (NiceAgent *agent, NiceSocket *sock) { GSList *i; for (i = agent->refresh_list; i;) { GSList *next = i->next; CandidateRefresh *refresh = i->data; if (refresh->nicesock == sock) { agent->refresh_list = g_slist_delete_link (agent->refresh_list, i); refresh_free_item (refresh); } i = next; } }
void refresh_prune_candidate (NiceAgent *agent, NiceCandidate *candidate) { GSList *i; for (i = agent->refresh_list; i;) { GSList *next = i->next; CandidateRefresh *refresh = i->data; if (refresh->candidate == candidate) { agent->refresh_list = g_slist_delete_link (agent->refresh_list, i); refresh_free_item (refresh); } i = next; } }
gboolean rcd_identity_remove_backend (RCDIdentityBackend *backend) { GSList *link; g_return_val_if_fail (backend != NULL, FALSE); link = g_slist_find (identity_backends, backend); if (!link) return FALSE; identity_backends = g_slist_delete_link (identity_backends, link); return TRUE; }
/** * nm_setting_wireless_remove_mac_blacklist_item: * @setting: the #NMSettingWireless * @idx: index number of the MAC address * * Removes the MAC address at index @idx from the blacklist. * * Since: 0.9.10 **/ void nm_setting_wireless_remove_mac_blacklist_item (NMSettingWireless *setting, guint32 idx) { NMSettingWirelessPrivate *priv; GSList *elt; g_return_if_fail (NM_IS_SETTING_WIRELESS (setting)); priv = NM_SETTING_WIRELESS_GET_PRIVATE (setting); elt = g_slist_nth (priv->mac_address_blacklist, idx); g_return_if_fail (elt != NULL); g_free (elt->data); priv->mac_address_blacklist = g_slist_delete_link (priv->mac_address_blacklist, elt); g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_MAC_ADDRESS_BLACKLIST); }
static void sync_proxies_use_underline (gpointer action, gboolean use_underline) { GSList *proxies; proxies = g_slist_copy (gtk_action_get_proxies (GTK_ACTION (action))); g_slist_foreach (proxies, (GFunc) g_object_ref, NULL); while (proxies) { proxy_set_use_underline (GTK_WIDGET (proxies->data), use_underline); g_object_unref (proxies->data); proxies = g_slist_delete_link (proxies, proxies); } }
static GstFlowReturn gst_wayland_sink_buffer_alloc (GstBaseSink * bsink, guint64 offset, guint size, GstCaps * caps, GstBuffer ** buf) { GstWaylandSink *sink = GST_WAYLAND_SINK (bsink); GstWlBuffer *buffer = NULL; GstFlowReturn ret = GST_FLOW_OK; GstStructure *structure = NULL; GstCaps *desired_caps = NULL; GST_LOG_OBJECT (sink, "a buffer of %u bytes was requested with caps " "%" GST_PTR_FORMAT " and offset %" G_GUINT64_FORMAT, size, caps, offset); desired_caps = gst_caps_copy (caps); structure = gst_caps_get_structure (desired_caps, 0); if (gst_structure_get_int (structure, "width", &sink->video_width) && gst_structure_get_int (structure, "height", &sink->video_height)) { sink->bpp = size / sink->video_width / sink->video_height; } g_mutex_lock (sink->pool_lock); while (sink->buffer_pool) { buffer = (GstWlBuffer *) sink->buffer_pool->data; if (buffer) { sink->buffer_pool = g_slist_delete_link (sink->buffer_pool, sink->buffer_pool); } else { break; } } g_mutex_unlock (sink->pool_lock); if (!buffer) buffer = wayland_buffer_create (sink); if (buffer) gst_buffer_set_caps (GST_BUFFER (buffer), caps); *buf = GST_BUFFER (buffer); gst_caps_unref (desired_caps); return ret; }
static void set_default_candidate_encodings (GtkSourceFileLoader *loader) { GSList *list; GSList *l; const GtkSourceEncoding *file_encoding; /* Get first the default candidates from GtkSourceEncoding. If the * GtkSourceFile's encoding has been set by a FileLoader or FileSaver, * put it at the beginning of the list. */ list = gtk_source_encoding_get_default_candidates (); if (loader->priv->file == NULL) { goto end; } file_encoding = gtk_source_file_get_encoding (loader->priv->file); if (file_encoding == NULL) { goto end; } /* Remove file_encoding from the list, if already present, and prepend * it to the list. */ for (l = list; l != NULL; l = l->next) { const GtkSourceEncoding *cur_encoding = l->data; if (cur_encoding == file_encoding) { list = g_slist_delete_link (list, l); /* The list doesn't contain duplicates, normally. */ break; } } list = g_slist_prepend (list, (gpointer) file_encoding); end: g_slist_free (loader->priv->candidate_encodings); loader->priv->candidate_encodings = list; }
gboolean falcon_filter_unregister(gboolean is_dir, const gchar *pattern, falcon_filter_func func) { GRegex *regex = NULL; GRegex *key = NULL; GSList *list = NULL; GSList *target = NULL; falcon_filter_t filter = {is_dir, func}; if (!pattern) { g_warning(_("Failed to unregister filter with no pattern.")); return FALSE; } regex = falcon_filter_regex_new(pattern); if (!regex) return FALSE; g_mutex_lock(lock); if (!registry) { g_critical(_("Filter registry uninitialized." " Failed to unregister filter with pattern %s"), pattern); g_mutex_unlock(lock); return FALSE; } if (!g_hash_table_lookup_extended(registry, regex, (gpointer *)&key, (gpointer *)&list)) { g_mutex_unlock(lock); return FALSE; } target = g_slist_find_custom(list, &filter, falcon_filter_compare); if (target) { g_free(target->data); list = g_slist_delete_link(list, target); } if (list == NULL) g_hash_table_remove(registry, key); else g_hash_table_insert(registry, key, list); g_regex_unref(regex); g_mutex_unlock(lock); return TRUE; }
/* remove highlight_link from the global highlight_list */ static void highlight_remove (GSList *highlight_link) { WarlockHighlight *highlight; GSList *cur; char *key; guint i, id; g_assert (highlight_link != NULL); highlight = highlight_link->data; g_assert (highlight != NULL); id = highlight->id; debug ("removing element: %X\n", id); /* remove the notifications on this highlight */ for (cur = highlight->gconf_connections; cur != NULL; cur = cur->next) { preferences_notify_remove (GPOINTER_TO_INT (cur->data)); } /* remove the tags, and delete the highlight from the list */ highlight_remove_tags (id); highlight_list = g_slist_delete_link (highlight_list, highlight_link); /* unset the gconf keys */ preferences_unset (preferences_get_highlight_key (id, PREF_HIGHLIGHT_STRING)); for (i = 0; i < HIGHLIGHT_MATCHES; i++) { preferences_unset (preferences_get_highlight_match_key (id, i, PREF_HIGHLIGHT_MATCH_TEXT_COLOR)); preferences_unset (preferences_get_highlight_match_key (id, i, PREF_HIGHLIGHT_MATCH_BASE_COLOR)); preferences_unset (preferences_get_highlight_match_key (id, i, PREF_HIGHLIGHT_MATCH_FONT)); } preferences_unset (preferences_get_highlight_key (id, PREF_HIGHLIGHT_CASE_SENSITIVE)); key = g_strdup_printf ("%s/%06X", preferences_get_key (PREF_HIGHLIGHTS), id); preferences_unset (key); g_free (key); }
static void startMovingNextTorrent( struct relocate_dialog_data * data ) { char * str; const int id = GPOINTER_TO_INT( data->torrent_ids->data ); tr_torrent * tor = gtr_core_find_torrent( data->core, id ); if( tor != NULL ) tr_torrentSetLocation( tor, previousLocation, data->do_move, NULL, &data->done ); data->torrent_ids = g_slist_delete_link( data->torrent_ids, data->torrent_ids ); str = g_strdup_printf( _( "Moving \"%s\"" ), tr_torrentName( tor ) ); gtk_message_dialog_set_markup( GTK_MESSAGE_DIALOG( data->message_dialog ), str ); g_free( str ); }
static void jabber_x_data_cancel_cb(struct jabber_x_data_data *data, GaimRequestFields *fields) { xmlnode *result = xmlnode_new("x"); jabber_x_data_cb cb = data->cb; gpointer user_data = data->user_data; JabberStream *js = data->js; g_hash_table_destroy(data->fields); while(data->values) { g_free(data->values->data); data->values = g_slist_delete_link(data->values, data->values); } g_free(data); xmlnode_set_namespace(result, "jabber:x:data"); xmlnode_set_attrib(result, "type", "cancel"); cb(js, result, user_data); }
/** * g_static_private_set: * @private_key: a #GStaticPrivate * @data: the new pointer * @notify: a function to be called with the pointer whenever the * current thread ends or sets this pointer again * * Sets the pointer keyed to @private_key for the current thread and * the function @notify to be called with that pointer (%NULL or * non-%NULL), whenever the pointer is set again or whenever the * current thread ends. * * This function works even if g_thread_init() has not yet been called. * If g_thread_init() is called later, the @data keyed to @private_key * will be inherited only by the main thread, i.e. the one that called * g_thread_init(). * * @notify is used quite differently from @destructor in g_private_new(). */ void g_static_private_set (GStaticPrivate *private_key, gpointer data, GDestroyNotify notify) { GArray *array; static guint next_index = 0; GStaticPrivateNode *node; if (!private_key->index) { G_LOCK (g_thread); if (!private_key->index) { if (g_thread_free_indices) { private_key->index = GPOINTER_TO_UINT (g_thread_free_indices->data); g_thread_free_indices = g_slist_delete_link (g_thread_free_indices, g_thread_free_indices); } else private_key->index = ++next_index; } G_UNLOCK (g_thread); } array = g_private_get (&static_private_private); if (!array) { array = g_array_new (FALSE, TRUE, sizeof (GStaticPrivateNode)); g_private_set (&static_private_private, array); } if (private_key->index > array->len) g_array_set_size (array, private_key->index); node = &g_array_index (array, GStaticPrivateNode, private_key->index - 1); if (node->destroy) node->destroy (node->data); node->data = data; node->destroy = notify; node->owner = private_key; }
/** * nm_setting_vlan_remove_priority: * @map: the type of priority map * @setting: the #NMSettingVlan * @idx: the zero-based index of the priority map to remove * * Removes the priority map at index @idx from the * #NMSettingVlan:ingress_priority_map or #NMSettingVlan:egress_priority_map * properties. */ void nm_setting_vlan_remove_priority (NMSettingVlan *setting, NMVlanPriorityMap map, guint32 idx) { GSList *list = NULL, *item = NULL; g_return_if_fail (NM_IS_SETTING_VLAN (setting)); g_return_if_fail (map == NM_VLAN_INGRESS_MAP || map == NM_VLAN_EGRESS_MAP); list = get_map (setting, map); g_return_if_fail (idx < g_slist_length (list)); item = g_slist_nth_data (list, idx); priority_map_free ((PriorityMap *) item); set_map (setting, map, g_slist_delete_link (list, item)); }
gboolean g_obex_remove_request_function(GObex *obex, guint id) { struct req_handler *handler; GSList *match; match = g_slist_find_custom(obex->req_handlers, GUINT_TO_POINTER(id), req_handler_cmpid); if (match == NULL) return FALSE; handler = match->data; obex->req_handlers = g_slist_delete_link(obex->req_handlers, match); g_free(handler); return TRUE; }