void
grg_recent_dox_push (const guchar * file)
{
GSList *cur, *tmp;
if (file == NULL)
return;
tmp = grg_recent_dox;
while (tmp)
{
cur = tmp;
tmp = tmp->next;
if (STR_EQ (cur->data, file) ||
(g_slist_position (grg_recent_dox, cur) >=
GRG_RECENT_LIMIT - 1))
{
grg_recent_dox =
g_slist_remove_link (grg_recent_dox, cur);
g_free (cur->data);
g_slist_free_1 (cur);
}
}
grg_recent_dox =
g_slist_prepend (grg_recent_dox, g_strdup ((guchar *) file));
recent_dox_save ();
grg_menu_update ();
}
/**
* g_slist_remove_all:
* @list: a #GSList
* @data: data to remove
*
* Removes all list nodes with data equal to @data.
* Returns the new head of the list. Contrast with
* g_slist_remove() which removes only the first node
* matching the given data.
*
* Returns: new head of @list
*/
GSList*
g_slist_remove_all (GSList *list,
gconstpointer data)
{
GSList *tmp, *prev = NULL;
tmp = list;
while (tmp)
{
if (tmp->data == data)
{
GSList *next = tmp->next;
if (prev)
prev->next = next;
else
list = next;
g_slist_free_1 (tmp);
tmp = next;
}
else
{
prev = tmp;
tmp = prev->next;
}
}
return list;
}
/* Called by gdk_x11_display_finalize to flush any cached cursors
* for a dead display.
*/
void
_gdk_x11_cursor_display_finalize (GdkDisplay *display)
{
GSList* item;
GSList** itemp; /* Pointer to the thing to fix when we delete an item */
item = cursor_cache;
itemp = &cursor_cache;
while (item)
{
GdkX11Cursor* cursor = (GdkX11Cursor*)(item->data);
if (gdk_cursor_get_display (GDK_CURSOR (cursor)) == display)
{
GSList* olditem;
gdk_cursor_unref ((GdkCursor*) cursor);
/* Remove this item from the list */
*(itemp) = item->next;
olditem = item;
item = g_slist_next (item);
g_slist_free_1 (olditem);
}
else
{
itemp = &(item->next);
item = g_slist_next (item);
}
}
}
/**
* gts_bb_tree_point_closest_bboxes:
* @tree: a bounding box tree.
* @p: a #GtsPoint.
*
* Returns: a list of #GtsBBox. One of the bounding boxes is assured to contain
* the object of @tree closest to @p.
*/
GSList * gts_bb_tree_point_closest_bboxes (GNode * tree,
GtsPoint * p)
{
gdouble min, min_max;
GSList * list = NULL, * i, * prev = NULL;
g_return_val_if_fail (tree != NULL, NULL);
g_return_val_if_fail (p != NULL, NULL);
gts_bbox_point_distance2 (tree->data, p, &min, &min_max);
min_max = bb_tree_min_max (tree, p, min_max, &list);
i = list;
while (i) {
GSList * next = i->next;
gdouble min, max;
gts_bbox_point_distance2 (i->data, p, &min, &max);
if (min > min_max) {
if (prev == NULL)
list = next;
else
prev->next = next;
g_slist_free_1 (i);
}
else
prev = i;
i = next;
}
return list;
}
/* remove all command callbacks with a given data pointer */
void sieve_sessions_discard_callbacks(gpointer user_data)
{
GSList *item;
GSList *queue;
GSList *prev = NULL;
SieveSession *session;
SieveCommand *cmd;
for (item = sessions; item; item = item->next) {
session = (SieveSession *)item->data;
cmd = session->current_cmd;
/* abort current command handler */
if (cmd && cmd->data == user_data) {
command_abort(cmd);
session->current_cmd = NULL;
}
/* abort queued command handlers */
for (queue = session->send_queue; queue; queue = queue->next) {
cmd = (SieveCommand *)queue->data;
if (cmd && cmd->data == user_data) {
if (prev)
prev->next = queue->next;
else
session->send_queue = NULL;
command_abort(cmd);
g_slist_free_1(queue);
} else {
prev = queue;
}
}
}
}
static size_t gstreamer_read_frames(struct input_handle* ih) {
size_t buf_pos = 0;
GSList *next;
while (ih->current_bytes < BUFFER_SIZE) {
GstBuffer *buf = gst_app_sink_pull_buffer(GST_APP_SINK(ih->appsink));
if (!buf) {
break;
}
ih->buffer_list = g_slist_append(ih->buffer_list, buf);
ih->current_bytes += buf->size;
}
while (ih->buffer_list &&
GST_BUFFER(ih->buffer_list->data)->size + buf_pos <= BUFFER_SIZE) {
memcpy((guint8 *) ih->buffer + buf_pos,
GST_BUFFER(ih->buffer_list->data)->data,
GST_BUFFER(ih->buffer_list->data)->size);
buf_pos += GST_BUFFER(ih->buffer_list->data)->size;
ih->current_bytes -= GST_BUFFER(ih->buffer_list->data)->size;
gst_buffer_unref(GST_BUFFER(ih->buffer_list->data));
next = ih->buffer_list->next;
g_slist_free_1(ih->buffer_list);
ih->buffer_list = next;
}
return buf_pos / sizeof(float) / gstreamer_get_channels(ih);
}
static void
_tarif_clear(gint tarif_id)
{
GSList **tarif = NULL;
GSList *link = NULL;
CCL_tarifpart *tp = NULL;
GData *freed = NULL;
tarif = g_new0(GSList *, 1);
*tarif = g_datalist_id_get_data(&ccl->tarifs, tarif_id);
g_assert(NULL != tarif);
g_datalist_init(&freed);
while ((link = g_slist_last(*tarif)) && *tarif)
{
*tarif = g_slist_remove_link(*tarif, link);
tp = (CCL_tarifpart *) link->data;
if (!g_datalist_id_get_data(&freed, GPOINTER_TO_INT(tp->prices)))
{
g_datalist_clear(tp->prices);
g_datalist_id_set_data(&freed, GPOINTER_TO_INT(tp->prices),
(void *)tp->prices);
g_free(tp->prices);
}
g_slist_free_1(link);
g_free(tp);
}
g_datalist_clear(&freed);
*tarif = NULL;
g_datalist_id_remove_data(&ccl->tarifs, tarif_id);
g_free(tarif);
}
GSList*
g_slist_remove_all (GSList *list, gconstpointer data)
{
GSList *next = list;
GSList *prev = NULL;
GSList *current;
while (next) {
GSList *tmp_prev = find_prev (next, data);
if (tmp_prev)
prev = tmp_prev;
current = prev ? prev->next : list;
if (!current)
break;
next = current->next;
if (prev)
prev->next = next;
else
list = next;
g_slist_free_1 (current);
}
return list;
}
/**
* g_thread_foreach:
* @thread_func: function to call for all #GThread structures
* @user_data: second argument to @thread_func
*
* Call @thread_func on all #GThreads that have been
* created with g_thread_create().
*
* Note that threads may decide to exit while @thread_func is
* running, so without intimate knowledge about the lifetime of
* foreign threads, @thread_func shouldn't access the GThread*
* pointer passed in as first argument. However, @thread_func will
* not be called for threads which are known to have exited already.
*
* Due to thread lifetime checks, this function has an execution complexity
* which is quadratic in the number of existing threads.
*
* Since: 2.10
*
* Deprecated:2.32: There aren't many things you can do with a #GThread,
* except comparing it with one that was returned from g_thread_create().
* There are better ways to find out if your thread is still alive.
*/
void
g_thread_foreach (GFunc thread_func,
gpointer user_data)
{
GSList *slist = NULL;
GRealThread *thread;
g_return_if_fail (thread_func != NULL);
/* snapshot the list of threads for iteration */
G_LOCK (g_thread);
slist = g_slist_copy (g_thread_all_threads);
G_UNLOCK (g_thread);
/* walk the list, skipping non-existent threads */
while (slist)
{
GSList *node = slist;
slist = node->next;
/* check whether the current thread still exists */
G_LOCK (g_thread);
if (g_slist_find (g_thread_all_threads, node->data))
thread = node->data;
else
thread = NULL;
G_UNLOCK (g_thread);
if (thread)
thread_func (thread, user_data);
g_slist_free_1 (node);
}
}
static void
impl_MateComponent_EventSource_removeListener (PortableServer_Servant servant,
const MateComponent_Listener listener,
CORBA_Environment *ev)
{
GSList *l, *next;
MateComponentEventSourcePrivate *priv;
priv = matecomponent_event_source_from_servant (servant)->priv;
for (l = priv->listeners; l; l = next) {
ListenerDesc *desc = l->data;
next = l->next;
if (CORBA_Object_is_equivalent (listener, desc->listener, ev)) {
priv->listeners = g_slist_remove_link (
priv->listeners, l);
g_slist_free_1 (l);
desc_free (desc, ev);
return;
}
}
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_MateComponent_EventSource_UnknownListener,
NULL);
}
/**
* main: Starts with an RPTable of 10 resources and fetches
* them randomly by the ResourceId and compares them against the original
* resource. A failed comparison means the test failed,
* otherwise the test passed.
*
* Return value: 0 on success, 1 on failure
**/
int main(int argc, char **argv)
{
RPTable *rptable = (RPTable *)g_malloc0(sizeof(RPTable));
guint i = 0, k = 0;
GSList *resources = NULL;
for (i = 0; rptentries[i].ResourceId != 0; i++) {
if (oh_add_resource(rptable, rptentries + i, NULL, 0))
return 1;
else
resources = g_slist_append(resources, rptentries + i);
}
for (; resources; i--) {
SaHpiRptEntryT *randentry = NULL, *tmpentry = NULL;
GSList *tmpnode = NULL;
k = (guint) (((gfloat)i)*rand()/(RAND_MAX+1.0));
tmpnode = g_slist_nth(resources, k);
randentry = (SaHpiRptEntryT *)tmpnode->data;
tmpentry =
oh_get_resource_by_id(rptable, randentry->ResourceId);
if (!tmpentry ||
memcmp(randentry, tmpentry, sizeof(SaHpiRptEntryT)))
return 1;
else {
resources = g_slist_remove_link(resources, tmpnode);
g_slist_free_1(tmpnode);
}
}
return 0;
}
/* Purge server output, either all or for specified target */
void irc_server_purge_output(IRC_SERVER_REC *server, const char *target)
{
GSList *tmp, *next, *link;
REDIRECT_REC *redirect;
char *cmd;
if (target != NULL && *target == '\0')
target = NULL;
for (tmp = server->cmdqueue; tmp != NULL; tmp = next) {
next = tmp->next->next;
cmd = tmp->data;
redirect = tmp->next->data;
if ((target == NULL || command_has_target(cmd, target)) &&
g_ascii_strncasecmp(cmd, "PONG ", 5) != 0) {
/* remove the redirection */
link = tmp->next;
server->cmdqueue =
g_slist_remove_link(server->cmdqueue, link);
g_slist_free_1(link);
if (redirect != NULL)
server_redirect_destroy(redirect);
/* remove the command */
server->cmdqueue =
g_slist_remove(server->cmdqueue, cmd);
g_free(cmd);
server->cmdcount--;
}
}
}
static void
remove_selected_layout (GtkWidget * button, GtkBuilder * dialog)
{
gint idx = find_selected_layout_idx (dialog);
if (idx != -1) {
GSList *layouts_list = xkb_layouts_get_selected_list ();
char *id = NULL;
GSList *node2Remove = g_slist_nth (layouts_list, idx);
layouts_list =
g_slist_remove_link (layouts_list, node2Remove);
id = (char *) node2Remove->data;
g_slist_free_1 (node2Remove);
g_free (id);
if (default_group > idx)
xkb_save_default_group (default_group - 1);
else if (default_group == idx)
xkb_save_default_group (-1);
xkb_layouts_set_selected_list (layouts_list);
clear_xkb_elements_list (layouts_list);
}
}
/**
* Deliver all the signals queued so far for the task.
*/
static void
bg_task_deliver_signals(struct bgtask *bt)
{
bg_task_check(bt);
g_assert(bt->flags & TASK_F_RUNNING);
/*
* Stop when list is empty or task has exited.
*
* Note that it is possible for a task to enqueue another signal
* whilst it is processing another.
*/
while (bt->signals != NULL) {
GSList *lnk = bt->signals;
bgsig_t sig = (bgsig_t) GPOINTER_TO_UINT(lnk->data);
/*
* If signal kills the thread (it calls bg_task_exit() from the
* handler), then we won't come back.
*/
bg_task_kill(bt, sig);
bt->signals = g_slist_remove_link(bt->signals, lnk);
g_slist_free_1(lnk);
}
}
static void
message_cancelled (NaTrayManager *manager,
GtkWidget *icon,
glong id,
TraysScreen *trays_screen)
{
IconTip *icontip;
IconTipBuffer find_buffer;
GSList *cancel_buffer_l;
IconTipBuffer *cancel_buffer;
icontip = g_hash_table_lookup (trays_screen->tip_table, icon);
if (icontip == NULL)
return;
if (icontip->id == id)
{
icon_tip_show_next (icontip);
return;
}
find_buffer.id = id;
cancel_buffer_l = g_slist_find_custom (icontip->buffer, &find_buffer,
icon_tip_buffer_compare);
if (cancel_buffer_l == NULL)
return;
cancel_buffer = cancel_buffer_l->data;
icon_tip_buffer_free (cancel_buffer, NULL);
icontip->buffer = g_slist_remove_link (icontip->buffer, cancel_buffer_l);
g_slist_free_1 (cancel_buffer_l);
}
static void
cb_pm_button_directory_delete_clicked (PluginManagerGUI *pm_gui)
{
GtkTreeIter iter;
char *dir_name = NULL;
gboolean is_system = TRUE;
GSList *extra_dirs, *res;
if (!gtk_tree_selection_get_selected (pm_gui->selection_directory, NULL, &iter))
return;
gtk_tree_model_get (GTK_TREE_MODEL (pm_gui->model_directories), &iter,
DIR_NAME, &dir_name,
DIR_IS_SYSTEM, &is_system,
-1);
extra_dirs = go_string_slist_copy (gnm_conf_get_plugins_extra_dirs ());
res = is_system
? NULL
: g_slist_find_custom (extra_dirs, dir_name, go_str_compare);
if (res) {
extra_dirs = g_slist_remove_link (extra_dirs, res);
g_free (res->data);
g_slist_free_1 (res);
gnm_conf_set_plugins_extra_dirs (extra_dirs);
pm_gui_load_directory_page (pm_gui);
cb_pm_button_rescan_directories_clicked (pm_gui);
}
g_slist_free_full (extra_dirs, g_free);
g_free (dir_name);
}
static void
cb_find_entry (GtkMenuItem *w, struct cb_find_entry *cl)
{
GtkWidget *sub;
if (cl->found)
return;
sub = gtk_menu_item_get_submenu (w);
if (sub) {
GSList *tmp = cl->path = g_slist_prepend (cl->path, GINT_TO_POINTER (cl->i));
cl->i = 0;
gtk_container_foreach (GTK_CONTAINER (sub), (GtkCallback)cb_find_entry, cl);
if (cl->found)
return;
cl->i = GPOINTER_TO_INT (cl->path->data);
cl->path = cl->path->next;
g_slist_free_1 (tmp);
} else {
const char *this_locale =
g_object_get_data (G_OBJECT (w), LOCALE_NAME_KEY);
if (this_locale && strcmp (this_locale, cl->locale) == 0) {
cl->found = TRUE;
cl->path = g_slist_prepend (cl->path, GINT_TO_POINTER (cl->i));
cl->path = g_slist_reverse (cl->path);
return;
}
}
cl->i++;
}
static gint sieve_pop_send_queue(SieveSession *session)
{
SieveCommand *cmd;
GSList *send_queue = session->send_queue;
if (session->current_cmd) {
command_free(session->current_cmd);
session->current_cmd = NULL;
}
if (!send_queue)
return SE_OK;
cmd = (SieveCommand *)send_queue->data;
session->send_queue = g_slist_next(send_queue);
g_slist_free_1(send_queue);
log_send(session, cmd);
session->state = cmd->next_state;
session->current_cmd = cmd;
if (session_send_msg(SESSION(session), SESSION_SEND, cmd->msg) < 0)
return SE_ERROR;
return SE_OK;
}
GSList *
gnm_slist_sort_merge (GSList *l1,
GSList *l2)
{
GSList list, *l;
l = &list;
while (l1 && l2) {
if (GPOINTER_TO_UINT (l1->data) <= GPOINTER_TO_UINT (l2->data)) {
if (GPOINTER_TO_UINT (l1->data) == GPOINTER_TO_UINT (l2->data)) {
/* remove duplicates */
GSList *m = l2;
l2 = l2->next;
m->next = NULL;
g_slist_free_1 (m);
}
l = l->next = l1;
l1 = l1->next;
} else {
l = l->next = l2;
l2 = l2->next;
}
}
l->next = l1 ? l1 : l2;
return list.next;
}
GSList*
g_slist_delete_link (GSList *list, GSList *link)
{
list = g_slist_remove_link (list, link);
g_slist_free_1 (link);
return list;
}
static size_t ffmpeg_read_frames(struct input_handle* ih) {
size_t buf_pos = 0, nr_frames_read;
GSList *next;
struct buffer_list_node *buf_node;
size_t frames_return;
if (ih->mp3_stop) return 0;
while (ih->current_bytes < BUFFER_SIZE * 2) {
nr_frames_read = ffmpeg_read_one_packet(ih);
if (!nr_frames_read) {
break;
}
buf_node = g_new(struct buffer_list_node, 1);
buf_node->size = nr_frames_read * ffmpeg_get_channels(ih) * sizeof(float);
buf_node->data = g_memdup(ih->buffer, (guint) buf_node->size);
ih->buffer_list = g_slist_append(ih->buffer_list, buf_node);
ih->current_bytes += buf_node->size;
}
while (ih->buffer_list &&
((struct buffer_list_node *) ih->buffer_list->data)->size + buf_pos <= BUFFER_SIZE) {
memcpy((guint8 *) ih->buffer + buf_pos,
((struct buffer_list_node *) ih->buffer_list->data)->data,
((struct buffer_list_node *) ih->buffer_list->data)->size);
buf_pos += ((struct buffer_list_node *) ih->buffer_list->data)->size;
ih->current_bytes -= ((struct buffer_list_node *) ih->buffer_list->data)->size;
g_free(((struct buffer_list_node *) ih->buffer_list->data)->data);
next = ih->buffer_list->next;
g_slist_free_1(ih->buffer_list);
ih->buffer_list = next;
}
frames_return = buf_pos / sizeof(float) / ffmpeg_get_channels(ih);
if (frames_return == 0) return 0;
if (ih->codec_context->codec_id == CODEC_ID_MP3 ||
ih->codec_context->codec_id == CODEC_ID_AAC) {
if (!ih->mp3_has_skipped_beginning) {
memmove(ih->buffer, ih->buffer + ih->mp3_padding_start * ffmpeg_get_channels(ih),
buf_pos - ih->mp3_padding_start * sizeof(float) * ffmpeg_get_channels(ih));
frames_return -= ih->mp3_padding_start;
ih->mp3_has_skipped_beginning = 1;
}
if (!ih->buffer_list) {
frames_return -= ih->mp3_padding_end;
} else if (ih->mp3_padding_end > ih->current_bytes / sizeof(float) / ffmpeg_get_channels(ih)) {
frames_return -= ih->mp3_padding_end - ih->current_bytes / sizeof(float) / ffmpeg_get_channels(ih);
ih->mp3_stop = 1;
}
}
return frames_return;
}
void
g_slist_free (GSList *list)
{
while (list) {
GSList *next = list->next;
g_slist_free_1 (list);
list = next;
}
}
static void
reflow_columns (EReflow *reflow)
{
GSList *list;
int count;
int start;
int i;
int column_count, column_start;
double running_height;
if (reflow->reflow_from_column <= 1) {
start = 0;
column_count = 1;
column_start = 0;
}
else {
/* we start one column before the earliest new entry,
so we can handle the case where the new entry is
inserted at the start of the column */
column_start = reflow->reflow_from_column - 1;
start = reflow->columns[column_start];
column_count = column_start + 1;
}
list = NULL;
running_height = E_REFLOW_BORDER_WIDTH;
count = reflow->count - start;
for (i = start; i < count; i++) {
int unsorted = e_sorter_sorted_to_model (E_SORTER (reflow->sorter), i);
if (i != 0 && running_height + reflow->heights[unsorted] + E_REFLOW_BORDER_WIDTH > reflow->height) {
list = g_slist_prepend (list, GINT_TO_POINTER(i));
column_count ++;
running_height = E_REFLOW_BORDER_WIDTH * 2 + reflow->heights[unsorted];
} else
running_height += reflow->heights[unsorted] + E_REFLOW_BORDER_WIDTH;
}
reflow->column_count = column_count;
reflow->columns = g_renew (int, reflow->columns, column_count);
column_count --;
for (; column_count > column_start; column_count--) {
GSList *to_free;
reflow->columns[column_count] = GPOINTER_TO_INT(list->data);
to_free = list;
list = list->next;
g_slist_free_1 (to_free);
}
reflow->columns[column_start] = start;
queue_incarnate (reflow);
reflow->need_reflow_columns = FALSE;
reflow->reflow_from_column = -1;
}
GIOPSendBuffer *
giop_send_buffer_use (GIOPVersion giop_version)
{
GIOPSendBuffer *buf;
g_return_val_if_fail (
((int) giop_version) >= 0 &&
giop_version < GIOP_NUM_VERSIONS, NULL);
LINK_MUTEX_LOCK (send_buffer_list_lock);
if (send_buffer_list) {
GSList *ltmp;
ltmp = send_buffer_list;
send_buffer_list = g_slist_remove_link (
send_buffer_list, ltmp);
LINK_MUTEX_UNLOCK (send_buffer_list_lock);
buf = ltmp->data;
g_slist_free_1 (ltmp);
buf->num_used = buf->indirect_left = 0;
if (giop_blank_wire_data) {
int i;
for (i = 0; i < buf->num_indirects_used; i++)
memset (buf->indirects [i].ptr, 0,
buf->indirects [i].size);
}
buf->num_indirects_used = 0;
} else {
LINK_MUTEX_UNLOCK (send_buffer_list_lock);
buf = g_new0 (GIOPSendBuffer, 1);
memcpy (buf->msg.header.magic, "GIOP", 4);
buf->msg.header.flags = GIOP_FLAG_ENDIANNESS;
buf->num_alloced = 8;
buf->iovecs = g_new (struct iovec, 8);
}
memcpy (buf->msg.header.version,
giop_version_ids [giop_version], 2);
buf->giop_version = giop_version;
g_assert (sizeof (buf->msg.header) == 12);
giop_send_buffer_append_real (
buf, (guchar *)&buf->msg.header, 12);
buf->msg.header.message_size = 0;
buf->header_size = 12;
return buf;
}
void uri_scope_pop_uri(UriScope *u)
{
if (!u->uri_stack)
return;
GSList *head = u->uri_stack;
_free_uri(head->data);
u->uri_stack = g_slist_next(u->uri_stack);
g_slist_free_1(head);
}
const IE_MimeConfidence * IE_ImpGraphicGdkPixbuf_Sniffer::getMimeConfidence ()
{
static IE_MimeConfidence *mimeConfidence = NULL;
if (mimeConfidence) {
return mimeConfidence;
}
GSList *formatList = gdk_pixbuf_get_formats ();
GSList *formatIter;
GdkPixbufFormat *format;
gsize idx;
std::vector<std::string> all_mime_types;
// dry run to count entries
formatIter = formatList;
while (formatIter) {
gchar **mime_types;
format = (GdkPixbufFormat *) formatIter->data;
mime_types = gdk_pixbuf_format_get_mime_types (format);
gchar **tmp = mime_types;
while (*tmp) {
all_mime_types.push_back(*tmp);
tmp++;
}
g_strfreev(mime_types);
GSList *node;
node = formatIter;
formatIter = formatIter->next;
g_slist_free_1(node);
}
mimeConfidence = new IE_MimeConfidence[all_mime_types.size() + 1];
idx = 0;
for(std::vector<std::string>::iterator iter = all_mime_types.begin();
iter != all_mime_types.end(); ++iter)
{
mimeConfidence[idx].match = IE_MIME_MATCH_FULL;
mimeConfidence[idx].mimetype = *iter;
if(*iter == "image/x-wmf") {
UT_DEBUGMSG(("WMF mime is only good\n"));
mimeConfidence[idx].confidence = UT_CONFIDENCE_GOOD;
}
else {
mimeConfidence[idx].confidence = UT_CONFIDENCE_PERFECT;
}
idx++;
}
// null-terminator
mimeConfidence[idx].match = IE_MIME_MATCH_BOGUS;
mimeConfidence[idx].confidence = UT_CONFIDENCE_ZILCH;
return mimeConfidence;
}
void
clear_xkb_elements_list (GSList * list)
{
while (list != NULL) {
GSList *p = list;
list = list->next;
g_free (p->data);
g_slist_free_1 (p);
}
}
/*!
* Get the null terminated array of recognized suffixes.
*/
static const SuffixInfo *
s_getSuffixInfo (void)
{
static SuffixInfo suffixInfo = { NULL, 0 };
static gboolean isInitialized = FALSE;
if (isInitialized) {
return &suffixInfo;
}
GSList *formatList = gdk_pixbuf_get_formats ();
GSList *formatIter;
GSList *tmp;
GdkPixbufFormat *format;
gchar **extensions;
gchar **extensionsIter;
gsize idx;
// dry run to count entries
formatIter = formatList;
while (formatIter) {
format = (GdkPixbufFormat *) formatIter->data;
extensionsIter = extensions = gdk_pixbuf_format_get_extensions (format);
while (*extensionsIter) {
suffixInfo.count++;
extensionsIter++;
}
g_strfreev(extensions);
formatIter = formatIter->next;
}
suffixInfo.suffixes = (const gchar **) new gchar*[suffixInfo.count + 1];
// build list
formatIter = formatList;
idx = 0;
while (formatIter) {
format = (GdkPixbufFormat *) formatIter->data;
extensionsIter = extensions = gdk_pixbuf_format_get_extensions (format);
while (*extensionsIter) {
suffixInfo.suffixes[idx] = g_strdup(*extensionsIter);
idx++;
extensionsIter++;
}
g_strfreev(extensions);
tmp = formatIter;
formatIter = formatIter->next;
g_slist_free_1 (tmp);
}
// null-terminator
suffixInfo.suffixes[idx] = NULL;
isInitialized = TRUE;
return &suffixInfo;
}
static PyObject*
replace(PygtsVertex *self, PyObject *args)
{
PyObject *p2_;
PygtsVertex *p2;
GSList *parents=NULL, *i, *cur;
SELF_CHECK
/* Parse the args */
if(! PyArg_ParseTuple(args, "O", &p2_) ) {
return NULL;
}
/* Convert to PygtsObjects */
if(!pygts_vertex_check(p2_)) {
PyErr_SetString(PyExc_TypeError,"expected a Vertex");
return NULL;
}
p2 = PYGTS_VERTEX(p2_);
if( self != p2 ) {
/* (Ignore self-replacement) */
/* Detach and save any parent segments */
i = PYGTS_VERTEX_AS_GTS_VERTEX(self)->segments;
while(i!=NULL) {
cur = i;
i = g_slist_next(i);
if(PYGTS_IS_PARENT_SEGMENT(cur->data)) {
PYGTS_VERTEX_AS_GTS_VERTEX(self)->segments =
g_slist_remove_link(PYGTS_VERTEX_AS_GTS_VERTEX(self)->segments,
cur);
parents = g_slist_prepend(parents,cur->data);
g_slist_free_1(cur);
}
}
/* Perform the replace operation */
gts_vertex_replace(PYGTS_VERTEX_AS_GTS_VERTEX(self),
PYGTS_VERTEX_AS_GTS_VERTEX(p2));
/* Reattach the parent segments */
i = parents;
while(i!=NULL) {
PYGTS_VERTEX_AS_GTS_VERTEX(self)->segments =
g_slist_prepend(PYGTS_VERTEX_AS_GTS_VERTEX(self)->segments,i->data);
i = g_slist_next(i);
}
g_slist_free(parents);
}
Py_INCREF(Py_None);
return Py_None;
}
GSList*
sixtp_pop_and_destroy_frame (GSList* frame_stack)
{
sixtp_stack_frame* dead_frame = (sixtp_stack_frame*) frame_stack->data;
GSList* result;
result = g_slist_next (frame_stack);
sixtp_stack_frame_destroy (dead_frame);
g_slist_free_1 (frame_stack);
return (result);
}
