static void
na_tray_manager_handle_begin_message (NaTrayManager *manager,
XClientMessageEvent *xevent)
{
GtkSocket *socket;
GList *p;
PendingMessage *msg;
long timeout;
long len;
long id;
socket = g_hash_table_lookup (manager->socket_table,
GINT_TO_POINTER (xevent->window));
/* we don't know about this tray icon, so ignore the message */
if (!socket)
return;
/* Check if the same message is already in the queue and remove it if so */
for (p = manager->messages; p; p = p->next)
{
PendingMessage *pmsg = p->data;
if (xevent->window == pmsg->window &&
xevent->data.l[4] == pmsg->id)
{
/* Hmm, we found it, now remove it */
pending_message_free (pmsg);
manager->messages = g_list_remove_link (manager->messages, p);
g_list_free_1 (p);
break;
}
}
timeout = xevent->data.l[2];
len = xevent->data.l[3];
id = xevent->data.l[4];
if (len == 0)
{
g_signal_emit (manager, manager_signals[MESSAGE_SENT], 0,
socket, "", id, timeout);
}
else
{
/* Now add the new message to the queue */
msg = g_new0 (PendingMessage, 1);
msg->window = xevent->window;
msg->timeout = timeout;
msg->len = len;
msg->id = id;
msg->remaining_len = msg->len;
msg->str = g_malloc (msg->len + 1);
msg->str[msg->len] = '\0';
manager->messages = g_list_prepend (manager->messages, msg);
}
}
t_launcher*
quicklauncher_remove_element(t_quicklauncher *quicklauncher, gint num)
{
t_launcher *result;
GList *elem = g_list_nth(quicklauncher->launchers, num);
quicklauncher->launchers = g_list_remove_link(quicklauncher->launchers, elem);
quicklauncher->nb_launcher--;
result = (t_launcher*)(elem->data);
g_list_free_1(elem);
return result;
}
void
gtk_plot_array_list_remove(GtkPlotArrayList *array_list, GtkPlotArray *array)
{
GList *list;
list = g_list_find(array_list->arrays, array);
if(list){
g_object_unref(G_OBJECT(array));
array_list->arrays = g_list_remove_link(array_list->arrays, list);
g_list_free_1(list);
}
}
static void
qof_event_generate_internal (QofInstance *entity, QofEventId event_id,
void * event_data)
{
GList *node;
GList *next_node = NULL;
g_return_if_fail(entity);
switch (event_id)
{
case QOF_EVENT_NONE:
{
/* if none, don't log, just return. */
return;
}
}
handler_run_level++;
for (node = handlers; node; node = next_node)
{
HandlerInfo *hi = node->data;
next_node = node->next;
if (hi->handler)
{
PINFO("id=%d hi=%p han=%p data=%p", hi->handler_id, hi,
hi->handler, event_data);
hi->handler (entity, event_id, hi->user_data, event_data);
}
}
handler_run_level--;
/* If we're the outermost event runner and we have pending deletes
* then go delete the handlers now.
*/
if (handler_run_level == 0 && pending_deletes)
{
for (node = handlers; node; node = next_node)
{
HandlerInfo *hi = node->data;
next_node = node->next;
if (hi->handler == NULL)
{
/* remove this node from the list, then free this node */
handlers = g_list_remove_link (handlers, node);
g_list_free_1 (node);
// g_free (hi);
delete hi;
}
}
pending_deletes = 0;
}
}
/**
* pango_find_map:
* @language: the language tag for which to find the map
* @engine_type_id: the engine type for the map to find
* @render_type_id: the render type for the map to find
*
* Locate a #PangoMap for a particular engine type and render
* type. The resulting map can be used to determine the engine
* for each character.
*
* Return value: the suitable #PangoMap.
**/
PangoMap *
pango_find_map (PangoLanguage *language,
guint engine_type_id,
guint render_type_id)
{
GList *tmp_list;
PangoMapInfo *map_info = NULL;
gboolean found_earlier = FALSE;
G_LOCK (maps);
tmp_list = maps;
while (tmp_list)
{
map_info = tmp_list->data;
if (map_info->engine_type_id == engine_type_id &&
map_info->render_type_id == render_type_id)
{
if (map_info->language == language)
break;
else
found_earlier = TRUE;
}
tmp_list = tmp_list->next;
}
if (!tmp_list)
{
map_info = g_slice_new (PangoMapInfo);
map_info->language = language;
map_info->engine_type_id = engine_type_id;
map_info->render_type_id = render_type_id;
build_map (map_info);
maps = g_list_prepend (maps, map_info);
}
else if (found_earlier)
{
/* Move the found map to the beginning of the list
* for speed next time around if we had to do
* any failing comparison. (No longer so important,
* since we don't strcmp.)
*/
maps = g_list_remove_link(maps, tmp_list);
maps = g_list_prepend(maps, tmp_list->data);
g_list_free_1(tmp_list);
}
G_UNLOCK (maps);
return map_info->map;
}
static void
queue_delete_link (GQueue *queue,
GList *link)
{
if (queue->tail == link)
queue->tail = link->prev;
queue->head = g_list_remove_link (queue->head, link);
g_list_free_1 (link);
queue->length--;
}
/*
int nh_poskey(int *x, int *y, int *mod)
-- Returns a single character input from the user or a
a positioning event (perhaps from a mouse). If the
return value is non-zero, a character was typed, else,
a position in the MAP window is returned in x, y and mod.
mod may be one of
CLICK_1 -- mouse click type 1
CLICK_2 -- mouse click type 2
The different click types can map to whatever the
hardware supports. If no mouse is supported, this
routine always returns a non-zero character.
*/
int dummy_nh_poskey(int *x, int *y, int *mod)
{
#if 0
gtk_signal_emit (GTK_OBJECT (dummy_windowlist[WIN_STATUS].win),
ghack_signals[GHSIG_FADE_HIGHLIGHT]);
g_askingQuestion = 0;
/* Process events until a key or map-click arrives. */
while ( g_numKeys == 0 && g_numClicks == 0 )
gtk_main_iteration();
if (g_numKeys > 0) {
int key;
GList *theFirst;
theFirst = g_list_first( g_keyBuffer);
g_keyBuffer = g_list_remove_link(g_keyBuffer, theFirst);
key = GPOINTER_TO_INT( theFirst->data);
g_list_free_1( theFirst);
g_numKeys--;
return ( key);
}
else {
GHClick *click;
GList *theFirst;
theFirst = g_list_first( g_clickBuffer);
g_clickBuffer = g_list_remove_link(g_clickBuffer, theFirst);
click = (GHClick*) theFirst->data;
*x=click->x;
*y=click->y;
*mod=click->mod;
g_free( click);
g_list_free_1( theFirst);
g_numClicks--;
return ( 0);
}
#endif
printf("dummy_nh_poskey\n");
return dummy_getchar();
}
/* Scans the list of missing subscriptions checking if they
* are available yet.
*/
static gboolean
im_scan_missing (gpointer user_data)
{
GList *nolonger_missing = NULL;
GList *l;
G_LOCK (inotify_lock);
IM_W ("scanning missing list with %d items\n", g_list_length (missing_sub_list));
for (l = missing_sub_list; l; l = l->next)
{
inotify_sub *sub = l->data;
gboolean not_m = FALSE;
IM_W ("checking %p\n", sub);
g_assert (sub);
g_assert (sub->dirname);
not_m = _ip_start_watching (sub);
if (not_m)
{
missing_cb (sub);
IM_W ("removed %s from missing list\n", sub->dirname);
/* We have to build a list of list nodes to remove from the
* missing_sub_list. We do the removal outside of this loop.
*/
nolonger_missing = g_list_prepend (nolonger_missing, l);
}
}
for (l = nolonger_missing; l ; l = l->next)
{
GList *llink = l->data;
missing_sub_list = g_list_remove_link (missing_sub_list, llink);
g_list_free_1 (llink);
}
g_list_free (nolonger_missing);
/* If the missing list is now empty, we disable the timeout */
if (missing_sub_list == NULL)
{
scan_missing_running = FALSE;
G_UNLOCK (inotify_lock);
return FALSE;
}
else
{
G_UNLOCK (inotify_lock);
return TRUE;
}
}
void playlist_queue_move(int oldpos, int newpos)
{
GList *tmp;
PL_LOCK();
tmp = g_list_nth(queued_list, oldpos);
queued_list = g_list_remove_link (queued_list, tmp);
queued_list = g_list_insert(queued_list, tmp->data, newpos);
g_list_free_1 (tmp);
PL_UNLOCK();
playlistwin_update_list();
}
static void playlist_queue_toggle(void *data)
{
GList *temp;
temp = g_list_find(queued_list, data);
if (temp)
{
queued_list = g_list_remove_link(queued_list, temp);
g_list_free_1(temp);
}
else
queued_list = g_list_append(queued_list, data);
}
void
_cogl_pipeline_snippet_list_free (CoglPipelineSnippetList *list)
{
GList *l, *tmp;
for (l = list->entries; l; l = tmp)
{
tmp = l->next;
cogl_object_unref (l->data);
g_list_free_1 (l);
}
}
/* Returns a node from the list of new nodes or NULL if there are no more
* new nodes */
node_t *
new_nodes_pop(void)
{
node_t *node = NULL;
GList *old_item = NULL;
if (!new_nodes)
return NULL;
node = new_nodes->data;
old_item = new_nodes;
/* We make sure now that the node hasn't been deleted since */
/* TODO Sometimes when I get here I have a node, but a null
* node->node_id. What gives? */
while (node && !nodes_catalog_find(&node->node_id))
{
g_my_debug
("Already deleted node in list of new nodes, in new_nodes_pop");
/* Remove this node from the list of new nodes */
new_nodes = g_list_remove_link (new_nodes, new_nodes);
g_list_free_1 (old_item);
if (new_nodes)
node = new_nodes->data;
else
node = NULL;
old_item = new_nodes;
}
if (!new_nodes)
return NULL;
/* Remove this node from the list of new nodes */
new_nodes = g_list_remove_link (new_nodes, new_nodes);
g_list_free_1 (old_item);
return node;
}
GList*
g_list_remove (GList *list, gconstpointer data)
{
GList *current = g_list_find (list, data);
if (!current)
return list;
if (current == list)
list = list->next;
g_list_free_1 (disconnect_node (current));
return list;
}
static int
ggu_git_wrapper_test_main (int argc,
char **argv)
{
int rv = 1;
loop_push ();
if (argc == 2) {
gchar *path;
gchar *dir;
gchar *file;
path = g_strdup (argv[1]);
dir = g_path_get_dirname (path);
file = g_path_get_basename (path);
loop_push ();
ggu_git_log (dir, NULL, file, log_result_callback, NULL);
loop_push ();
ggu_git_branch_list (dir, branch_list_result_callback, NULL);
rv = 0;
{
GList *l;
GError *err = NULL;
l = ggu_git_log_sync (dir, NULL, file, &err);
if (err) {
g_warning ("%s", err->message);
g_error_free (err);
} else {
printf ("=== Commit(s) ===\n");
while (l) {
GguGitCommit *commit = l->data;
GList *next = l->next;
printf ("%.7s -- %s\n", commit->hash, commit->summary);
ggu_git_commit_unref (commit);
g_list_free_1 (l);
l = next;
}
}
}
g_free (file);
g_free (dir);
g_free (path);
}
loop_pop ();
return rv;
}
static void explorer_prune_history (Explorer* self, int max_nodes)
{
while (self->history_queue->length > max_nodes) {
GList* link = g_queue_pop_head_link(self->history_queue);
if (!link)
break;
if (link == self->history_current_link)
self->history_current_link = NULL;
history_node_free(link->data);
g_list_free_1(link);
}
}
/* FIXME: This doesn't work properly if the iterator is the first
iterator in the list. Well, the iterator doesn't continue on after
the next time next is called, at least. */
void
e_list_remove_link (EList *list, GList *link)
{
GList *iterators = list->iterators;
for (; iterators; iterators = iterators->next) {
if (((EListIterator *)iterators->data)->iterator == link) {
e_iterator_prev (iterators->data);
}
}
if (list->free)
list->free (link->data, list->closure);
list->list = g_list_remove_link (list->list, link);
g_list_free_1 (link);
}
void quotelist_delete(QuoteList * list, QuoteInfo * quote)
{
GList *scan;
for (scan = list->quotes; scan != NULL; scan = g_list_next(scan)) {
if (scan->data == quote) {
list->quotes =
g_list_remove_link(list->quotes, scan);
g_list_free_1(scan);
g_free(quote);
return;
}
}
}
static void free_rule_list(GList *rule_list)
{
while (rule_list)
{
struct rule *cur_rule = rule_list->data;
list_free_with_free(cur_rule->conditions);
free(cur_rule->command);
free(cur_rule);
GList *next = rule_list->next;
g_list_free_1(rule_list);
rule_list = next;
}
}
static GdkFilterReturn
na_tray_manager_handle_client_message_message_data (GdkXEvent *xev,
GdkEvent *event,
gpointer data)
{
XClientMessageEvent *xevent;
NaTrayManager *manager;
GList *p;
int len;
xevent = (XClientMessageEvent *) xev;
manager = data;
/* Try to see if we can find the pending message in the list */
for (p = manager->messages; p; p = p->next)
{
PendingMessage *msg = p->data;
if (xevent->window == msg->window)
{
/* Append the message */
len = MIN (msg->remaining_len, 20);
memcpy ((msg->str + msg->len - msg->remaining_len),
&xevent->data, len);
msg->remaining_len -= len;
if (msg->remaining_len == 0)
{
GtkSocket *socket;
socket = g_hash_table_lookup (manager->socket_table,
GINT_TO_POINTER (msg->window));
if (socket)
g_signal_emit (manager, manager_signals[MESSAGE_SENT], 0,
socket, msg->str, msg->id, msg->timeout);
pending_message_free (msg);
manager->messages = g_list_remove_link (manager->messages, p);
g_list_free_1 (p);
}
break;
}
}
return GDK_FILTER_REMOVE;
}
void lru_cache_kicks(struct lruCache* c, void* user_data,
int (*func)(void* elem, void* user_data)) {
GList* elem = g_list_last(c->elem_queue);
while (elem) {
if (func(elem->data, user_data))
break;
elem = g_list_previous(elem);
}
if (elem) {
c->elem_queue = g_list_remove_link(c->elem_queue, elem);
c->free_elem(elem->data);
g_list_free_1(elem);
c->size--;
}
}
/*
* We know that the elem does not exist!
*/
void* lru_cache_insert(LRUCache *cache, void* data) {
void *evictor = 0;
if (cache->cache_max_size > 0
&& cache->cache_size == cache->cache_max_size) {
GList *last = g_list_last(cache->lru_queue);
cache->lru_queue = g_list_remove_link(cache->lru_queue, last);
evictor = last->data;
g_list_free_1(last);
cache->cache_size--;
}
/* Valgrind reports it's possible to lost some memory here */
cache->lru_queue = g_list_prepend(cache->lru_queue, data);
cache->cache_size++;
return evictor;
}
GdkEvent *gdk_event_unqueue(void)
{
GdkEvent *event = NULL;
GList *tmp_list;
tmp_list = gdk_event_queue_find_first();
if (tmp_list) {
event = tmp_list->data;
gdk_event_queue_remove_link(tmp_list);
g_list_free_1(tmp_list);
}
return event;
}
/* Container method
*/
static void
gtk_form_remove(GtkContainer *container, GtkWidget *widget)
{
GList *tmp_list;
GtkForm *form;
GtkFormChild *child = NULL; /* init for gcc */
g_return_if_fail(GTK_IS_FORM(container));
form = GTK_FORM(container);
tmp_list = form->children;
while (tmp_list)
{
child = tmp_list->data;
if (child->widget == widget)
break;
tmp_list = tmp_list->next;
}
if (tmp_list)
{
#if GTK_CHECK_VERSION(3,0,0)
const gboolean was_visible = gtk_widget_get_visible(widget);
#endif
if (child->window)
{
g_signal_handlers_disconnect_by_func(G_OBJECT(child->widget),
FUNC2GENERIC(>k_form_child_map), child);
g_signal_handlers_disconnect_by_func(G_OBJECT(child->widget),
FUNC2GENERIC(>k_form_child_unmap), child);
/* FIXME: This will cause problems for reparenting NO_WINDOW
* widgets out of a GtkForm
*/
gdk_window_set_user_data(child->window, NULL);
gdk_window_destroy(child->window);
}
gtk_widget_unparent(widget);
#if GTK_CHECK_VERSION(3,0,0)
if (was_visible)
gtk_widget_queue_resize(GTK_WIDGET(container));
#endif
form->children = g_list_remove_link(form->children, tmp_list);
g_list_free_1(tmp_list);
g_free(child);
}
}
/* inotify_lock must be held before calling */
void im_rm (ih_sub_t *sub)
{
GList *link;
link = g_list_find (missing_sub_list, sub);
if (!link) {
IM_W("asked to remove %s from missing list but it isn't on the list!\n", sub->pathname);
return;
}
IM_W("removing %s from missing list\n", sub->dirname);
missing_sub_list = g_list_remove_link (missing_sub_list, link);
g_list_free_1 (link);
}
gpointer
tracker_priority_queue_pop (TrackerPriorityQueue *queue,
gint *priority_out)
{
GList *node;
gpointer data;
node = tracker_priority_queue_pop_node (queue, priority_out);
if (node == NULL)
return NULL;
data = node->data;
g_list_free_1 (node);
return data;
}
void
win_destroy(void *ptr) {
Win *w;
GList *l;
w = (Win*)ptr;
gtk_widget_destroy(GTK_WIDGET(w->web));
gtk_widget_destroy(GTK_WIDGET(w->scroll));
gtk_widget_destroy(GTK_WIDGET(w->win));
if((l = g_list_find(data.wins, w))) {
data.wins = g_list_remove_link(data.wins, l);
g_list_free_1(l);
}
free(w);
if(!data.wins)
gtk_main_quit();
}
int main(int argc, char** argv) {
GList* list = g_list_append(NULL, "Austin ");
list = g_list_append(list, "Bowie ");
list = g_list_append(list, "Chicago ");
printf("Here's the list: ");
g_list_foreach(list, (GFunc)printf, NULL);
GList* bowie = g_list_nth(list, 1);
list = g_list_remove_link(list, bowie);
g_list_free_1(bowie);
printf("\nHere's the list after the remove_link call: ");
g_list_foreach(list, (GFunc)printf, NULL);
list = g_list_delete_link(list, g_list_nth(list, 1));
printf("\nHere's the list after the delete_link call: ");
g_list_foreach(list, (GFunc)printf, NULL);
g_list_free(list);
return 0;
}
static void
clear_dup (gpointer key,
gpointer value,
gpointer data)
{
GList *dupes;
/* don't bother maintaining the ring, we're destroying the
* entire hash table anyway
*/
dupes = g_object_get_data (G_OBJECT (value), "dupes");
if (dupes) {
g_list_free_1 (dupes);
g_object_set_data (G_OBJECT (value), "dupes", NULL);
}
}
void
gtk_plot_array_list_clear(GtkPlotArrayList *array_list)
{
GList *list;
list = array_list->arrays;
while(list){
if(list->data && G_IS_OBJECT(list->data))
g_object_unref(G_OBJECT(list->data));
list->data = NULL;
array_list->arrays = g_list_remove_link(array_list->arrays, list);
g_list_free_1(list);
list = array_list->arrays;
}
array_list->arrays = NULL;
}
static gboolean gs_idle_cb(gpointer data)
{
PurpleStringref *ref;
GList *del;
while (gclist != NULL) {
ref = gclist->data;
if (REFCOUNT(ref->ref) == 0) {
stringref_free(ref);
}
del = gclist;
gclist = gclist->next;
g_list_free_1(del);
}
return FALSE;
}
