GSList*
g_slist_sort (GSList *list,
GCompareFunc compare_func)
{
GSList *l1, *l2;
if (!list)
return NULL;
if (!list->next)
return list;
l1 = list;
l2 = list->next;
while ((l2 = l2->next) != NULL)
{
if ((l2 = l2->next) == NULL)
break;
l1=l1->next;
}
l2 = l1->next;
l1->next = NULL;
return g_slist_sort_merge (g_slist_sort (list, compare_func),
g_slist_sort (l2, compare_func),
compare_func);
}
RESULT
test_slist_sort ()
{
int i, j, mul;
GSList *list = NULL;
for (i = 0; i < N_ELEMS; ++i)
list = g_slist_prepend (list, GINT_TO_POINTER (i));
list = g_slist_sort (list, intcompare);
if (!verify_sort (list, N_ELEMS))
return FAILED ("decreasing list");
g_slist_free (list);
list = NULL;
for (i = 0; i < N_ELEMS; ++i)
list = g_slist_prepend (list, GINT_TO_POINTER (-i));
list = g_slist_sort (list, intcompare);
if (!verify_sort (list, N_ELEMS))
return FAILED ("increasing list");
g_slist_free (list);
list = g_slist_prepend (NULL, GINT_TO_POINTER (0));
for (i = 1; i < N_ELEMS; ++i) {
list = g_slist_prepend (list, GINT_TO_POINTER (-i));
list = g_slist_prepend (list, GINT_TO_POINTER (i));
}
list = g_slist_sort (list, intcompare);
if (!verify_sort (list, 2*N_ELEMS-1))
return FAILED ("alternating list");
g_slist_free (list);
list = NULL;
mul = 1;
for (i = 1; i < N_ELEMS; ++i) {
mul = -mul;
for (j = 0; j < i; ++j)
list = g_slist_prepend (list, GINT_TO_POINTER (mul * j));
}
list = g_slist_sort (list, intcompare);
if (!verify_sort (list, (N_ELEMS*N_ELEMS - N_ELEMS)/2))
return FAILED ("wavering list");
g_slist_free (list);
return OK;
}
GSList *
g_slist_agregate(GSList * list, GCompareFunc comparator)
{
GSList *resL2 = NULL; /*a list of lists of chunk_info_t */
GSList *sorted = NULL; /*a list of chunk_info_t */
GSList *cursor1 = NULL;
GSList *last_agregate = NULL;
if (!list)
return NULL;
sorted = g_slist_copy(list);
if (!sorted)
return NULL;
sorted = g_slist_sort(sorted, comparator);
if (!sorted)
return NULL;
for (cursor1 = sorted; cursor1; cursor1 = cursor1->next) {
if (!cursor1->data)
continue;
if (last_agregate && 0 > comparator(last_agregate->data, cursor1->data)) {
resL2 = g_slist_prepend(resL2, last_agregate);
last_agregate = NULL;
}
last_agregate = g_slist_prepend(last_agregate, cursor1->data);
}
if (last_agregate)
resL2 = g_slist_prepend(resL2, last_agregate);
g_slist_free (sorted);
return g_slist_reverse(resL2);
}
void
gst_debugserver_log_send_debug_categories (GstDebugserverTcp * tcp_server,
TcpClient * client)
{
GstDebugger__GStreamerData gst_data = GST_DEBUGGER__GSTREAMER_DATA__INIT;
GstDebugger__DebugCategories debug_categories =
GST_DEBUGGER__DEBUG_CATEGORIES__INIT;
gint categories_count, i = 0;
gst_data.info_type_case =
GST_DEBUGGER__GSTREAMER_DATA__INFO_TYPE_DEBUG_CATEGORIES;
GSList *tmp, *all_categories = gst_debug_get_all_categories ();
tmp = all_categories = g_slist_sort (all_categories, sort_by_category_name);
categories_count = g_slist_length (all_categories);
debug_categories.n_category = categories_count;
debug_categories.category =
(char **) g_malloc (sizeof (char *) * categories_count);
while (tmp) {
GstDebugCategory *cat = (GstDebugCategory *) tmp->data;
debug_categories.category[i++] = (char *) gst_debug_category_get_name (cat);
tmp = g_slist_next (tmp);
}
g_slist_free (all_categories);
gst_data.debug_categories = &debug_categories;
gst_debugserver_tcp_send_packet (tcp_server, client, &gst_data);
g_free (debug_categories.category);
}
void
panel_object_loader_do_load (gboolean initial_load)
{
if (!panel_objects_to_load) {
panel_object_loader_queue_initial_unhide_toplevels (NULL);
return;
}
if (panel_objects_to_load && panel_object_loader_unhide_toplevels_timeout == 0) {
/* Install a timeout to make sure we don't block the
* unhiding because of an object that doesn't load */
panel_object_loader_unhide_toplevels_timeout =
g_timeout_add_seconds (UNHIDE_TOPLEVELS_TIMEOUT_SECONDS,
panel_object_loader_queue_initial_unhide_toplevels,
NULL);
}
panel_objects_to_load = g_slist_sort (panel_objects_to_load,
(GCompareFunc) panel_object_compare);
if (!panel_object_loader_have_idle) {
/* on panel startup, we don't care about redraws of the
* toplevels since they are hidden, so we give a higher
* priority to loading of objects */
if (initial_load)
g_idle_add_full (G_PRIORITY_HIGH_IDLE,
panel_object_loader_idle_handler,
NULL, NULL);
else
g_idle_add (panel_object_loader_idle_handler, NULL);
panel_object_loader_have_idle = TRUE;
}
}
GSList *
pluma_style_scheme_manager_list_schemes_sorted (GtkSourceStyleSchemeManager *manager)
{
const gchar * const * scheme_ids;
GSList *schemes = NULL;
g_return_val_if_fail (GTK_IS_SOURCE_STYLE_SCHEME_MANAGER (manager), NULL);
scheme_ids = gtk_source_style_scheme_manager_get_scheme_ids (manager);
while (*scheme_ids != NULL)
{
GtkSourceStyleScheme *scheme;
scheme = gtk_source_style_scheme_manager_get_scheme (manager,
*scheme_ids);
schemes = g_slist_prepend (schemes, scheme);
++scheme_ids;
}
if (schemes != NULL)
schemes = g_slist_sort (schemes, (GCompareFunc)schemes_compare);
return schemes;
}
void iiTimeReport()
{
g_printf("\n********************** Time Report **********************\n");
if(g_slist_length(timeList) > 0) {
// sort events by global occurence
timeList = g_slist_sort(timeList, compare_time_events);
GSList* iter = timeList;
gint lastprocid = 0;
g_printf(" [P] [#] [event] [seconds]\n");
for(;iter;iter=g_slist_next(iter)) {
TimeEvent* event = (TimeEvent*) iter->data;
if(event->proc != lastprocid) {
g_printf("---------------------------------------------------------\n");
}
g_printf(" %2d %3d %28s %13.6fs\n", event->proc, event->id, event->name, event->value);
lastprocid = event->proc;
}
g_printf("\n");
g_printf("[P] - Process rank\n");
g_printf("[#] - Execution order of the time command\n");
g_printf("[event] - Time event label\n");
g_printf("[seconds] - Duration of the time event\n");
}
else {
g_printf("No time events.\n");
}
}
int main(int argc, char** argv) {
GSList* list = NULL;
Person* tom = (Person*)malloc(sizeof(Person));
tom->name = "Tom";
tom->shoe_size = 10;
list = g_slist_append(list, tom);
Person* fred = g_new(Person, 1); // allocate memory for one Person struct
fred->name = "yred";
fred->shoe_size = 11;
list = g_slist_append(list, fred);
Person* god = g_new(Person, 1); // allocate memory for one Person struct
god->name = "zod";
god->shoe_size = 15;
list = g_slist_append(list, god);
list = g_slist_sort(list, (GCompareFunc)my_comparator);
printf("Tom's shoe size is '%d'\n", ((Person*)list->data)->shoe_size);
printf("The last Person's name is '%s'\n", ((Person*)g_slist_last(list)->data)->name);
g_slist_free(list);
free(tom);
g_free(fred);
g_free(god);
return 0;
}
static GSList *
create_core_text_glyph_list (const char *text,
gint length,
CTFontRef ctfont)
{
GSList *glyph_list = NULL;
struct RunIterator riter;
if (!run_iterator_create (&riter, text, length, ctfont))
return NULL;
while (!run_iterator_at_end (&riter))
{
struct GlyphInfo *gi;
gi = g_slice_new (struct GlyphInfo);
gi->index = run_iterator_get_index (&riter);
gi->cgglyph = run_iterator_get_cgglyph (&riter);
gi->wc = run_iterator_get_character (&riter);
glyph_list = g_slist_prepend (glyph_list, gi);
run_iterator_advance (&riter);
}
glyph_list = g_slist_sort (glyph_list, glyph_info_compare_func);
run_iterator_free (&riter);
return glyph_list;
}
GInputStream *
soup_message_setup_body_istream (GInputStream *body_stream,
SoupMessage *msg,
SoupSession *session,
SoupProcessingStage start_at_stage)
{
GInputStream *istream;
GSList *p, *processors;
istream = g_object_ref (body_stream);
processors = soup_session_get_features (session, SOUP_TYPE_CONTENT_PROCESSOR);
processors = g_slist_sort (processors, processing_stage_cmp);
for (p = processors; p; p = p->next) {
GInputStream *wrapper;
SoupContentProcessor *processor;
processor = SOUP_CONTENT_PROCESSOR (p->data);
if (soup_message_disables_feature (msg, p->data) ||
soup_content_processor_get_processing_stage (processor) < start_at_stage)
continue;
wrapper = soup_content_processor_wrap_input (processor, istream, msg, NULL);
if (wrapper) {
g_object_unref (istream);
istream = wrapper;
}
}
g_slist_free (processors);
return istream;
}
GSList *
cedit_language_manager_list_languages_sorted (GtkSourceLanguageManager *lm,
gboolean include_hidden)
{
GSList *languages = NULL;
const gchar * const *ids;
ids = gtk_source_language_manager_get_language_ids (lm);
if (ids == NULL)
return NULL;
while (*ids != NULL)
{
GtkSourceLanguage *lang;
lang = gtk_source_language_manager_get_language (lm, *ids);
#if GTK_CHECK_VERSION (3, 0, 0)
g_return_val_if_fail (GTK_SOURCE_IS_LANGUAGE (lang), NULL);
#else
g_return_val_if_fail (GTK_IS_SOURCE_LANGUAGE (lang), NULL);
#endif
++ids;
if (include_hidden || !gtk_source_language_get_hidden (lang))
{
languages = g_slist_prepend (languages, lang);
}
}
return g_slist_sort (languages, (GCompareFunc)language_compare);
}
void pixmap_cache_clear (GSList **cache, int maxitems) {
GSList *tmp = NULL;
GSList *last = NULL;
struct cached_pixmap *cp;
if (cache && *cache) {
if (maxitems > 0) {
*cache = g_slist_sort (*cache, (GCompareFunc) cached_pixmap_cmp);
for (tmp = *cache; (maxitems-- > 0) && tmp; tmp = tmp->next) {
cp = (struct cached_pixmap *) tmp->data;
cp->weight /= 2;
last = tmp;
}
if (last)
last->next = NULL;
}
else {
tmp = *cache;
*cache = NULL;
}
g_slist_foreach (tmp, (GFunc) free_cached_pixmap, NULL);
g_slist_free (tmp);
}
}
static gboolean
idle_handle_recent_changed (gpointer data)
{
ShellDocSystem *self = SHELL_DOC_SYSTEM (data);
GList *items, *iter;
self->priv->idle_recent_changed_id = 0;
g_hash_table_remove_all (self->priv->deleted_infos);
g_hash_table_remove_all (self->priv->infos_by_uri);
g_slist_free (self->priv->infos_by_timestamp);
self->priv->infos_by_timestamp = NULL;
items = gtk_recent_manager_get_items (self->priv->manager);
for (iter = items; iter; iter = iter->next)
{
GtkRecentInfo *info = iter->data;
const char *uri = gtk_recent_info_get_uri (info);
/* uri is owned by the info */
g_hash_table_insert (self->priv->infos_by_uri, (char*) uri, info);
self->priv->infos_by_timestamp = g_slist_prepend (self->priv->infos_by_timestamp, info);
}
g_list_free (items);
self->priv->infos_by_timestamp = g_slist_sort (self->priv->infos_by_timestamp, sort_infos_by_timestamp_descending);
g_signal_emit (self, signals[CHANGED], 0);
return FALSE;
}
/* Create widgets to represent the options made available by the backend */
void
xkb_options_load_options (GtkBuilder * dialog)
{
GtkWidget *opts_vbox = WID ("options_vbox");
GSList *expanders_list;
GtkWidget *expander;
current1st_level_id = NULL;
current_none_radio = NULL;
current_multi_select = FALSE;
current_radio_group = NULL;
/* fill the list */
xkl_config_registry_foreach_option_group (config_registry,
(ConfigItemProcessFunc)
xkb_options_add_group,
dialog);
/* sort it */
expanders_list =
g_object_get_data (G_OBJECT (dialog), EXPANDERS_PROP);
expanders_list =
g_slist_sort (expanders_list,
(GCompareFunc) xkb_options_expanders_compare);
g_object_set_data (G_OBJECT (dialog), EXPANDERS_PROP,
expanders_list);
while (expanders_list) {
expander = GTK_WIDGET (expanders_list->data);
gtk_box_pack_start (GTK_BOX (opts_vbox), expander, FALSE,
FALSE, 0);
expanders_list = expanders_list->next;
}
gtk_widget_show_all (opts_vbox);
}
void
mate_panel_applet_load_queued_applets (gboolean initial_load)
{
if (!mate_panel_applets_to_load) {
mate_panel_applet_queue_initial_unhide_toplevels (NULL);
return;
}
if (mate_panel_applets_to_load && mate_panel_applet_unhide_toplevels_timeout == 0) {
/* Install a timeout to make sure we don't block the
* unhiding because of an applet that doesn't load */
mate_panel_applet_unhide_toplevels_timeout =
g_timeout_add_seconds (UNHIDE_TOPLEVELS_TIMEOUT_SECONDS,
mate_panel_applet_queue_initial_unhide_toplevels,
NULL);
}
mate_panel_applets_to_load = g_slist_sort (mate_panel_applets_to_load,
(GCompareFunc) mate_panel_applet_compare);
if ( ! mate_panel_applet_have_load_idle) {
/* on panel startup, we don't care about redraws of the
* toplevels since they are hidden, so we give a higher
* priority to loading of applets */
if (initial_load)
g_idle_add_full (G_PRIORITY_HIGH_IDLE,
mate_panel_applet_load_idle_handler,
NULL, NULL);
else
g_idle_add (mate_panel_applet_load_idle_handler, NULL);
mate_panel_applet_have_load_idle = TRUE;
}
}
/**
* shell_window_tracker_get_running_apps:
* @monitor: An app monitor instance
* @context: Activity identifier
*
* Returns the set of applications which currently have at least one open
* window in the given context. The returned list will be sorted
* by shell_app_compare().
*
* Returns: (element-type ShellApp) (transfer full): Active applications
*/
GSList *
shell_window_tracker_get_running_apps (ShellWindowTracker *monitor,
const char *context)
{
gpointer key, value;
GSList *ret;
GHashTableIter iter;
g_hash_table_iter_init (&iter, monitor->running_apps);
ret = NULL;
while (g_hash_table_iter_next (&iter, &key, &value))
{
ShellApp *app = value;
if (strcmp (context, _shell_window_tracker_get_app_context (monitor, app)) != 0)
continue;
ret = g_slist_prepend (ret, g_object_ref (app));
}
ret = g_slist_sort (ret, (GCompareFunc)shell_app_compare);
return ret;
}
void
icontainer_pos_sort( iContainer *icontainer )
{
icontainer->children = g_slist_sort( icontainer->children,
(GCompareFunc) icontainer_pos_compare );
iobject_changed( IOBJECT( icontainer ) );
}
static GSList *
append_nmt_devices_for_devices (GSList *nmt_devices,
const GPtrArray *devices,
char **names,
const GPtrArray *connections)
{
NmtConnectDevice *nmtdev;
NMDevice *device;
int i, sort_order;
for (i = 0; i < devices->len; i++) {
device = devices->pdata[i];
sort_order = get_sort_order_for_device (device);
if (sort_order == -1)
continue;
nmtdev = g_slice_new0 (NmtConnectDevice);
nmtdev->name = g_strdup (names[i]);
nmtdev->device = g_object_ref (device);
nmtdev->sort_order = sort_order;
if (NM_IS_DEVICE_WIFI (device))
add_connections_for_aps (nmtdev, connections);
else
add_connections_for_device (nmtdev, connections);
nmtdev->conns = g_slist_sort (nmtdev->conns, sort_connections);
nmt_devices = g_slist_prepend (nmt_devices, nmtdev);
}
return nmt_devices;
}
static GSList *hosts_to_cache (void) {
GSList *hosts = NULL;
GSList *allhosts;
GSList *tmp;
struct host *h;
time_t curtime = time (NULL);
allhosts = all_hosts ();
for (tmp = allhosts; tmp; tmp = tmp->next) {
h = (struct host *) tmp->data;
if (h->name && h->refreshed &&
h->refreshed < curtime + HOST_CACHE_MAX_AGE*2) {
hosts = g_slist_prepend (hosts, h);
host_ref (h);
}
}
host_list_free (allhosts);
hosts = g_slist_sort (hosts, (GCompareFunc) host_cache_sorting_helper);
if (g_slist_length (hosts) > HOST_CACHE_MAX_SIZE) {
tmp = g_slist_nth (hosts, HOST_CACHE_MAX_SIZE - 1);
host_list_free (tmp->next);
tmp->next = NULL;
}
return hosts;
}
json_t*
format_workspaces (i3ipcConnection *conn) {
json_t *json_data_object = json_object();
json_t *json_desktops_array = json_array();
json_object_set_new(json_data_object, "desktops", json_desktops_array);
GSList *workspaces = i3ipc_connection_get_workspaces(conn, NULL);
workspaces = g_slist_sort(workspaces, (GCompareFunc)workspace_comparator);
for (unsigned char i = 0; i < g_slist_length(workspaces); i++) {
GSList *workspace = g_slist_nth(workspaces, i);
i3ipcWorkspaceReply *data = workspace->data;
json_t *json_desktop = json_object();
json_object_set_new(json_desktop, "name", json_string(data->name));
json_object_set_new(json_desktop, "clients_len", json_integer(i));
json_object_set_new(json_desktop, "is_urgent", json_boolean(data->urgent));
json_array_append_new(json_desktops_array, json_desktop);
if (data->focused) {
json_object_set_new(json_data_object, "current_desktop", json_integer(i));
}
}
return json_data_object;
}
static void
gwy_app_file_chooser_add_types(GtkListStore *store,
GwyFileOperationType fileop,
gboolean only_nondetectable)
{
TypeListData tldata;
GtkTreeIter iter;
GSList *l;
tldata.list = NULL;
tldata.fileop = fileop;
tldata.only_nondetectable = only_nondetectable;
gwy_file_func_foreach((GFunc)gwy_app_file_chooser_add_type, &tldata);
tldata.list = g_slist_sort(tldata.list, gwy_app_file_chooser_type_compare);
for (l = tldata.list; l; l = g_slist_next(l)) {
gtk_list_store_insert_with_values
(store, &iter, G_MAXINT,
COLUMN_FILETYPE, l->data,
COLUMN_LABEL, gettext(gwy_file_func_get_description(l->data)),
-1);
}
g_slist_free(tldata.list);
}
static int
gsf_list_props (int argc, char **argv)
{
GsfInfile *infile;
GsfDocMetaData *meta_data;
char const *filename;
GSList *names = NULL;
if (argc != 1)
return 1;
filename = argv[0];
infile = open_archive (filename);
if (!infile)
return 1;
meta_data = get_meta_data (infile, filename);
gsf_doc_meta_data_foreach (meta_data, cb_collect_names, &names);
names = g_slist_sort (names, (GCompareFunc)strcmp);
g_slist_foreach (names, (GFunc)cb_print_names, NULL);
g_slist_free (names);
g_object_unref (meta_data);
g_object_unref (infile);
return 0;
}
static void
write_xml_wire (Wire *wire, parseXmlContext *ctxt)
{
xmlNodePtr node_wire;
gchar *str;
Coords start_pos, end_pos;
g_return_if_fail (wire != NULL);
g_return_if_fail (IS_WIRE (wire));
// Create a node for the wire.
node_wire = xmlNewChild (ctxt->node_wires, ctxt->ns, BAD_CAST "wire", NULL);
if (!node_wire) {
g_warning ("Failed during save of wire.\n");
return;
}
wire_get_start_pos (wire, &start_pos);
wire_get_end_pos (wire, &end_pos);
Node *node;
Coords last, current, tmp;
GSList *iter, *copy;
copy = g_slist_sort (g_slist_copy (wire_get_nodes (wire)), cmp_nodes);
current = last = start_pos;
for (iter = copy; iter; iter = iter->next) {
node = iter->data;
if (node==NULL) {
g_warning ("Node of wire did not exist [%p].", node);
continue;
}
tmp = node->key;
if (coords_equal(&tmp, &start_pos))
continue;
if (coords_equal(&tmp, &end_pos))
continue;
last = current;
current = tmp;
str = g_strdup_printf ("(%g %g)(%g %g)",
last.x, last.y, current.x, current.y);
xmlNewChild (node_wire, ctxt->ns, BAD_CAST "points", BAD_CAST str);
g_free (str);
}
last = current;
current = end_pos;
str = g_strdup_printf ("(%g %g)(%g %g)",
last.x, last.y, current.x, current.y);
xmlNewChild (node_wire, ctxt->ns, BAD_CAST "points", BAD_CAST str);
g_free (str);
g_slist_free (copy);
}
void
icontainer_custom_sort( iContainer *icontainer, GCompareFunc fn )
{
icontainer->children = g_slist_sort( icontainer->children, fn );
icontainer_pos_renumber( icontainer );
iobject_changed( IOBJECT( icontainer ) );
}
static void
workspaceview_layout_loop( WorkspaceLayout *layout )
{
layout->cview = NULL;
layout->area.left = INT_MAX;
slist_map( layout->undone_columns,
(SListMapFn) workspaceview_layout_find_leftmost, layout );
layout->current_columns = NULL;
layout->area.width = GTK_WIDGET( layout->cview )->allocation.width;
slist_map( layout->undone_columns,
(SListMapFn) workspaceview_layout_find_similar_x, layout );
layout->current_columns = g_slist_sort( layout->current_columns,
(GCompareFunc) workspaceview_layout_sort_y );
layout->out_y = workspaceview_layout_top;
slist_map( layout->current_columns,
(SListMapFn) workspaceview_layout_set_pos, layout );
layout->out_x += layout->area.width + workspaceview_layout_hspacing;
slist_map( layout->current_columns,
(SListMapFn) workspaceview_layout_strike, layout );
IM_FREEF( g_slist_free, layout->current_columns );
}
GSList *
panel_g_slist_make_unique (GSList *list,
GCompareFunc compare,
gboolean free_data)
{
GSList *sorted, *l;
g_assert (compare != NULL);
if (!list)
return NULL;
sorted = g_slist_copy (list);
sorted = g_slist_sort (sorted, compare);
for (l = sorted; l; l = l->next) {
GSList *next;
next = l->next;
if (l->data && next && next->data)
if (!compare (l->data, next->data)) {
list = g_slist_remove (list, l->data);
if (free_data)
g_free (l->data);
}
}
g_slist_free (sorted);
return list;
}
static void
query_completed_cb (EphyHistoryService *service,
gboolean success,
gpointer result_data,
FindURLsData *user_data)
{
EphyCompletionModel *model = user_data->model;
EphyCompletionModelPrivate *priv = model->priv;
GList *p, *urls;
GPtrArray *children;
GSList *list = NULL;
int i;
/* Bookmarks */
children = ephy_node_get_children (priv->bookmarks);
/* FIXME: perhaps this could be done in a service thread? There
* should never be a ton of bookmarks, but seems a bit cleaner and
* consistent with what we do for the history. */
for (i = 0; i < children->len; i++) {
EphyNode *kid;
const char *keywords, *location, *title;
kid = g_ptr_array_index (children, i);
location = ephy_node_get_property_string (kid, EPHY_NODE_BMK_PROP_LOCATION);
title = ephy_node_get_property_string (kid, EPHY_NODE_BMK_PROP_TITLE);
keywords = ephy_node_get_property_string (kid, EPHY_NODE_BMK_PROP_KEYWORDS);
if (should_add_bookmark_to_model (model, user_data->search_string,
title, location, keywords))
list = add_to_potential_rows (list, title, location, keywords, 0, TRUE, FALSE);
}
/* History */
urls = (GList*)result_data;
for (p = urls; p != NULL; p = p->next) {
EphyHistoryURL *url = (EphyHistoryURL*)p->data;
list = add_to_potential_rows (list, url->title, url->url, NULL, url->visit_count, FALSE, TRUE);
}
/* Sort the rows by relevance. */
list = g_slist_sort (list, sort_by_relevance);
/* Now that we have all the rows we want to insert, replace the rows
* in the current model one by one, sorted by relevance. */
replace_rows_in_model (model, list);
/* Notify */
if (user_data->callback)
user_data->callback (service, success, result_data, user_data->user_data);
g_free (user_data->search_string);
g_slice_free (FindURLsData, user_data);
g_list_free_full (urls, (GDestroyNotify)ephy_history_url_free);
g_slist_free_full (list, (GDestroyNotify)free_potential_row);
g_clear_object (&priv->cancellable);
}
void vfsInitDirectory (const char *path)
{
char filename[PATH_MAX];
//struct dirent *direntry;
GDir *dir;
GSList *dirlist = NULL;
if (g_numDirs == (VFS_MAXDIRS-1))
return;
strcpy (g_strDirs[g_numDirs], path);
vfsFixDOSName (g_strDirs[g_numDirs]);
vfsAddSlash (g_strDirs[g_numDirs]);
g_numDirs++;
if (g_bUsePak)
{
dir = g_dir_open (path, 0, NULL);
if (dir != NULL)
{
g_FuncTable.m_pfnSysPrintf("vfs directory: %s\n", path);
for(;;)
{
const char* name = g_dir_read_name(dir);
if(name == NULL)
break;
char *ext = strrchr (name, '.');
if ((ext == NULL) || (strcasecmp (ext, ".pak") != 0))
continue;
char* direntry = g_strdup(name);
dirlist = g_slist_append (dirlist, direntry);
}
g_dir_close (dir);
// sort them
dirlist = g_slist_sort (dirlist, vfsPakSort);
// add the entries to the vfs and free the list
while (dirlist)
{
GSList *cur = dirlist;
char* name = (char*)cur->data;
sprintf (filename, "%s/%s", path, name);
vfsInitPakFile (filename);
g_free (name);
dirlist = g_slist_remove (cur, name);
}
} else
g_FuncTable.m_pfnSysFPrintf(SYS_WRN, "vfs directory not found: %s\n", path);
}
}
static void
load_stock_items (GtkToolPalette *palette)
{
GtkWidget *group_af = gtk_tool_item_group_new ("Stock Icons (A-F)");
GtkWidget *group_gn = gtk_tool_item_group_new ("Stock Icons (G-N)");
GtkWidget *group_or = gtk_tool_item_group_new ("Stock Icons (O-R)");
GtkWidget *group_sz = gtk_tool_item_group_new ("Stock Icons (S-Z)");
GtkWidget *group = NULL;
GtkToolItem *item;
GSList *stock_ids;
GSList *iter;
stock_ids = gtk_stock_list_ids ();
stock_ids = g_slist_sort (stock_ids, (GCompareFunc) strcmp);
gtk_container_add (GTK_CONTAINER (palette), group_af);
gtk_container_add (GTK_CONTAINER (palette), group_gn);
gtk_container_add (GTK_CONTAINER (palette), group_or);
gtk_container_add (GTK_CONTAINER (palette), group_sz);
for (iter = stock_ids; iter; iter = g_slist_next (iter))
{
GtkStockItem stock_item;
gchar *id = iter->data;
switch (id[4])
{
case 'a':
group = group_af;
break;
case 'g':
group = group_gn;
break;
case 'o':
group = group_or;
break;
case 's':
group = group_sz;
break;
}
item = gtk_tool_button_new_from_stock (id);
gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM (item), id);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (item), TRUE);
gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
if (!gtk_stock_lookup (id, &stock_item) || !stock_item.label)
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), id);
g_free (id);
}
g_slist_free (stock_ids);
}
void riscv_cpu_list(void)
{
GSList *list;
list = object_class_get_list(TYPE_RISCV_CPU, false);
list = g_slist_sort(list, riscv_cpu_list_compare);
g_slist_foreach(list, riscv_cpu_list_entry, NULL);
g_slist_free(list);
}
