/** * Adds an instance to the deferred list of the SX. Added instances are * added in (date-)sorted order. **/ void gnc_sx_add_defer_instance( SchedXaction *sx, void *deferStateData ) { sx->deferredList = g_list_insert_sorted( sx->deferredList, deferStateData, _temporal_state_data_cmp ); }
/** duplicate a existant module */ dt_iop_module_t *dt_dev_module_duplicate(dt_develop_t *dev, dt_iop_module_t *base, int priority) { //we create the new module dt_iop_module_t *module = (dt_iop_module_t *)malloc(sizeof(dt_iop_module_t)); if (dt_iop_load_module(module,base->so,base->dev)) return NULL; module->instance = base->instance; //we set the multi-instance priority if (priority < 0) { GList *modules = g_list_first(base->dev->iop); int pmax = 0; while(modules) { dt_iop_module_t *mod = (dt_iop_module_t *)modules->data; if(mod->instance == base->instance) { if (pmax < mod->multi_priority) pmax = mod->multi_priority; } modules = g_list_next(modules); } module->multi_priority = pmax + 1; } else module->multi_priority = priority; //the multi instance name snprintf(module->multi_name,128,"%d",module->multi_priority); //we insert this module into dev->iop base->dev->iop = g_list_insert_sorted(base->dev->iop, module, sort_plugins); //that's all. rest of insertion is gui work ! return module; }
static gboolean gtk_level_bar_ensure_offset (GtkLevelBar *self, const gchar *name, gdouble value) { GList *existing; GtkLevelBarOffset *offset = NULL; GtkLevelBarOffset *new_offset; existing = g_list_find_custom (self->priv->offsets, name, offset_find_func); if (existing) offset = existing->data; if (offset && (offset->value == value)) return FALSE; new_offset = gtk_level_bar_offset_new (name, value); if (offset) { gtk_level_bar_offset_free (offset); self->priv->offsets = g_list_delete_link (self->priv->offsets, existing); } self->priv->offsets = g_list_insert_sorted (self->priv->offsets, new_offset, offset_sort_func); return TRUE; }
void EraseUndoAction::addEdited(Layer* layer, Stroke* element, int pos) { XOJ_CHECK_TYPE(EraseUndoAction); this->edited = g_list_insert_sorted(this->edited, new PageLayerPosEntry<Stroke> (layer, element, pos), (GCompareFunc) PageLayerPosEntry<Stroke>::cmp); }
gboolean xmms_magic_add (const gchar *desc, const gchar *mime, ...) { GNode *tree, *node = NULL; va_list ap; gchar *s; gpointer *root_props; gboolean ret = TRUE; g_return_val_if_fail (desc, FALSE); g_return_val_if_fail (mime, FALSE); /* now process the magic specs in the argument list */ va_start (ap, mime); s = va_arg (ap, gchar *); if (!s) { /* no magic specs passed -> failure */ va_end (ap); return FALSE; } /* root node stores the description and the mimetype */ root_props = g_new0 (gpointer, 2); root_props[0] = g_strdup (desc); root_props[1] = g_strdup (mime); tree = g_node_new (root_props); do { if (!*s) { ret = FALSE; xmms_log_error ("invalid magic spec: '%s'", s); break; } s = g_strdup (s); /* we need our own copy */ node = xmms_magic_add_node (tree, s, node); g_free (s); if (!node) { xmms_log_error ("invalid magic spec: '%s'", s); ret = FALSE; break; } } while ((s = va_arg (ap, gchar *))); va_end (ap); /* only add this tree to the list if all spec chunks are valid */ if (ret) { magic_list = g_list_insert_sorted (magic_list, tree, (GCompareFunc) cb_sort_magic_list); } else { xmms_magic_tree_free (tree); } return ret; }
static GList * gst_oss4_property_probe_get_mixer_devices (GstObject * obj, int fd, struct oss_sysinfo *si) { GList *m, *mixers = NULL; GList *devices = NULL; int i; GST_LOG_OBJECT (obj, "%d mixer devices", si->nummixers); /* first, find suitable mixer devices and sort by priority */ for (i = 0; i < si->nummixers; ++i) { struct oss_mixerinfo mi = { 0, }; mi.dev = i; if (ioctl (fd, SNDCTL_MIXERINFO, &mi) == -1) { GST_DEBUG_OBJECT (obj, "MIXERINFO ioctl for device %d failed", i); continue; } GST_INFO_OBJECT (obj, "mixer device %d:", i); GST_INFO_OBJECT (obj, " enabled : %s", (mi.enabled) ? "yes" : "no (powered off or unplugged)"); GST_INFO_OBJECT (obj, " priority : %d", mi.priority); GST_INFO_OBJECT (obj, " devnode : %s", mi.devnode); GST_INFO_OBJECT (obj, " handle : %s", mi.handle); GST_INFO_OBJECT (obj, " caps : 0x%02x", mi.caps); GST_INFO_OBJECT (obj, " name : %s", mi.name); if (!mi.enabled) { GST_DEBUG_OBJECT (obj, "mixer device is not usable/enabled, skipping"); continue; } /* only want mixers that control hardware directly */ if ((mi.caps & MIXER_CAP_VIRTUAL)) { GST_DEBUG_OBJECT (obj, "mixer device is a virtual device, skipping"); continue; } mixers = g_list_insert_sorted (mixers, g_memdup (&mi, sizeof (mi)), (GCompareFunc) oss4_mixerinfo_priority_cmp); } /* then create device list according to priority */ for (m = mixers; m != NULL; m = m->next) { struct oss_mixerinfo *mi = (struct oss_mixerinfo *) m->data; GST_LOG_OBJECT (obj, "mixer device: '%s'", mi->devnode); devices = g_list_prepend (devices, g_strdup (mi->devnode)); g_free (m->data); } g_list_free (mixers); mixers = NULL; return g_list_reverse (devices); }
void filter_register_import(DiaImportFilter *ifilter) { if (ifilter->description == NULL) { return; } import_filters = g_list_insert_sorted(import_filters, ifilter, import_filter_compare); }
static void crm_add_member( gpointer key, gpointer value, gpointer user_data) { GList **list = user_data; crm_node_t *node = value; if(node->uname != NULL) { *list = g_list_insert_sorted(*list, node, member_sort); } }
void filter_register_export(DiaExportFilter *efilter) { if (efilter->description == NULL) { return; } export_filters = g_list_insert_sorted(export_filters, efilter, export_filter_compare); }
gboolean purple_plugin_register(PurplePlugin *plugin) { g_return_val_if_fail(plugin != NULL, FALSE); /* If this plugin has been registered already then exit */ if (g_list_find(plugins, plugin)) return TRUE; /* Ensure the plugin has the requisite information */ if (plugin->info->type == PURPLE_PLUGIN_LOADER) { PurplePluginLoaderInfo *loader_info; loader_info = PURPLE_PLUGIN_LOADER_INFO(plugin); if (loader_info == NULL) { purple_debug_error("plugins", "%s is not loadable, loader plugin missing loader_info\n", plugin->path); return FALSE; } } else if (plugin->info->type == PURPLE_PLUGIN_PROTOCOL) { PurplePluginProtocolInfo *prpl_info; prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin); if (prpl_info == NULL) { purple_debug_error("plugins", "%s is not loadable, protocol plugin missing prpl_info\n", plugin->path); return FALSE; } } #ifdef PURPLE_PLUGINS /* This plugin should be probed and maybe loaded--add it to the queue */ load_queue = g_list_append(load_queue, plugin); #else if (plugin->info != NULL) { if (plugin->info->type == PURPLE_PLUGIN_PROTOCOL) protocol_plugins = g_list_insert_sorted(protocol_plugins, plugin, (GCompareFunc)compare_prpl); if (plugin->info->load != NULL) if (!plugin->info->load(plugin)) return FALSE; } #endif plugins = g_list_append(plugins, plugin); return TRUE; }
void MetadataManager::cleanupMetadata() { XOJ_CHECK_TYPE(MetadataManager); GList* data = NULL; gsize lenght = 0; gchar** groups = g_key_file_get_groups(this->config, &lenght); for (gsize i = 0; i < lenght; i++) { char* group = groups[i]; GFile* file = g_file_new_for_uri(group); bool exists = g_file_query_exists(file, NULL); g_object_unref(file); if (!exists) { g_key_file_remove_group(this->config, group, NULL); continue; } GError* error = NULL; // TODO LOW PRIO: newer GTK Version use _int64 instead of integer int time = g_key_file_get_integer(this->config, group, "atime", &error); if (error) { g_error_free(error); continue; } GroupTimeEntry* e = g_new(GroupTimeEntry, 1); e->group = group; e->time = time; data = g_list_insert_sorted(data, e, (GCompareFunc) timeCompareFunc); } int count = g_list_length(data); GList* d = data; if (count > METADATA_MAX_ITEMS) { for (int i = count - METADATA_MAX_ITEMS; i > 0 && d; i--) { GroupTimeEntry* e = (GroupTimeEntry*) d->data; g_key_file_remove_group(this->config, e->group, NULL); d = d->next; } } g_list_foreach(data, (GFunc) g_free, NULL); g_list_free(data); g_strfreev(groups); }
/** * pk_gst_structure_to_provide: **/ static gchar * pk_gst_structure_to_provide (GstStructure *s) { GString *string; guint i, num_fields; GList *l; _cleanup_list_free_ GList *fields = NULL; num_fields = gst_structure_n_fields (s); fields = NULL; for (i = 0; i < num_fields; i++) { const gchar *field_name; field_name = gst_structure_nth_field_name (s, i); if (pk_gst_field_get_type (field_name) < 0) { g_message ("PackageKit: ignoring field named %s", field_name); continue; } fields = g_list_insert_sorted (fields, g_strdup (field_name), (GCompareFunc) pk_gst_fields_type_compare); } string = g_string_new(""); for (l = fields; l != NULL; l = l->next) { gchar *field_name; GType type; field_name = l->data; type = gst_structure_get_field_type (s, field_name); g_message ("PackageKit: field is: %s, type: %s", field_name, g_type_name (type)); if (type == G_TYPE_INT) { int value; gst_structure_get_int (s, field_name, &value); g_string_append_printf (string, "(%s=%d)", field_name, value); } else if (type == G_TYPE_BOOLEAN) { int value; gst_structure_get_boolean (s, field_name, &value); g_string_append_printf (string, "(%s=%s)", field_name, value ? "true" : "false"); } else if (type == G_TYPE_STRING) { const gchar *value; value = gst_structure_get_string (s, field_name); g_string_append_printf (string, "(%s=%s)", field_name, value); } else { g_warning ("PackageKit: unhandled type! %s", g_type_name (type)); } g_free (field_name); } return g_string_free (string, FALSE); }
static void lease_set_expire(GDHCPServer *dhcp_server, struct dhcp_lease *lease, uint32_t expire) { dhcp_server->lease_list = g_list_remove(dhcp_server->lease_list, lease); lease->expire = expire; dhcp_server->lease_list = g_list_insert_sorted(dhcp_server->lease_list, lease, compare_expire); }
void cairo_dock_move_icon_after_icon (CairoDock *pDock, Icon *icon1, Icon *icon2) { //g_print ("%s (%s, %.2f, %x)\n", __func__, icon1->acName, icon1->fOrder, icon2); ///if ((icon2 != NULL) && (! ( (CAIRO_DOCK_IS_APPLI (icon1) && CAIRO_DOCK_IS_APPLI (icon2)) || (CAIRO_DOCK_IS_LAUNCHER (icon1) && CAIRO_DOCK_IS_LAUNCHER (icon2)) || (CAIRO_DOCK_IS_APPLET (icon1) && CAIRO_DOCK_IS_APPLET (icon2)) ) )) if ((icon2 != NULL) && fabs (cairo_dock_get_icon_order (icon1) - cairo_dock_get_icon_order (icon2)) > 1) return ; //\_________________ On change l'ordre de l'icone. gboolean bForceUpdate = FALSE; if (icon2 != NULL) { Icon *pNextIcon = cairo_dock_get_next_icon (pDock->icons, icon2); if (pNextIcon != NULL && fabs (pNextIcon->fOrder - icon2->fOrder) < 1e-3) { bForceUpdate = TRUE; } if (pNextIcon == NULL || cairo_dock_get_icon_order (pNextIcon) != cairo_dock_get_icon_order (icon2)) icon1->fOrder = icon2->fOrder + 1; else icon1->fOrder = (pNextIcon->fOrder - icon2->fOrder > 1 ? icon2->fOrder + 1 : (pNextIcon->fOrder + icon2->fOrder) / 2); } else { Icon *pFirstIcon = cairo_dock_get_first_icon_of_order (pDock->icons, icon1->iType); if (pFirstIcon != NULL) icon1->fOrder = pFirstIcon->fOrder - 1; else icon1->fOrder = 1; } //g_print ("icon1->fOrder:%.2f\n", icon1->fOrder); //\_________________ On change l'ordre dans le fichier du lanceur 1. if ((CAIRO_DOCK_IS_LAUNCHER (icon1) || CAIRO_DOCK_IS_SEPARATOR (icon1)) && icon1->acDesktopFileName != NULL) { gchar *cDesktopFilePath = g_strdup_printf ("%s/%s", g_cCurrentLaunchersPath, icon1->acDesktopFileName); cairo_dock_update_conf_file (cDesktopFilePath, G_TYPE_DOUBLE, "Desktop Entry", "Order", icon1->fOrder, G_TYPE_INVALID); g_free (cDesktopFilePath); } else if (CAIRO_DOCK_IS_APPLET (icon1)) cairo_dock_update_module_instance_order (icon1->pModuleInstance, icon1->fOrder); //\_________________ On change sa place dans la liste. pDock->pFirstDrawnElement = NULL; pDock->icons = g_list_remove (pDock->icons, icon1); pDock->icons = g_list_insert_sorted (pDock->icons, icon1, (GCompareFunc) cairo_dock_compare_icons_order); //\_________________ On recalcule la largeur max, qui peut avoir ete influencee par le changement d'ordre. cairo_dock_update_dock_size (pDock); if (bForceUpdate) cairo_dock_normalize_icons_order (pDock->icons, icon1->iType); }
void mex_plugin_manager_refresh (MexPluginManager *manager) { gint i; MexPluginManagerPrivate *priv = manager->priv; g_return_if_fail (MEX_IS_PLUGIN_MANAGER (manager)); for (i = 0; priv->search_paths[i]; i++) { GDir *dir; const gchar *file; GList *files = NULL; GError *error = NULL; if (!g_file_test (priv->search_paths[i], G_FILE_TEST_IS_DIR)) continue; if (!(dir = g_dir_open (priv->search_paths[i], 0, &error))) { g_warning (G_STRLOC ": Couldn't open directory: %s", error->message); g_error_free (error); continue; } /* Build the sorted plugin list */ files = NULL; while ((file = g_dir_read_name (dir))) { gchar *full_file; if (!g_str_has_suffix (file, ".so") && !g_str_has_suffix (file, ".la")) continue; full_file = g_build_filename (priv->search_paths[i], file, NULL); files = g_list_insert_sorted (files, full_file, (GCompareFunc)g_strcmp0); } g_dir_close (dir); /* Load the plugins */ while (files) { gchar *full_file = files->data; /* Try to load plugin */ mex_plugin_manager_load_plugin (manager, full_file); g_free (full_file); files = g_list_delete_link (files, files); } } }
void register_stat_tap_ui(stat_tap_ui *ui, void *userdata) { stat_cmd_arg *newsca; newsca=(stat_cmd_arg *)g_malloc(sizeof(stat_cmd_arg)); newsca->cmd=ui->cli_string; newsca->func=ui->tap_init_cb; newsca->userdata=userdata; stat_cmd_arg_list=g_list_insert_sorted(stat_cmd_arg_list, newsca, sort_by_name); }
static void _insert_icon (GldiContainer *pContainer, Icon *pIcon, G_GNUC_UNUSED gboolean bAnimateIcon) { CairoDesklet *pDesklet = CAIRO_DESKLET (pContainer); // insert icon pDesklet->icons = g_list_insert_sorted (pDesklet->icons, pIcon, (GCompareFunc)cairo_dock_compare_icons_order); cairo_dock_set_icon_container (pIcon, pDesklet); // calculate icons _update_desklet_icons (pDesklet); }
/* * read bandmap spots from file, put them to allspots list */ void bmdata_read_file() { FILE * fp; struct timeval tv; int timediff, last_bm_save_time, fc; char line[50], *token; static int bmdata_parsed = 0; if ((fp = fopen(".bmdata.dat", "r")) != NULL && bmdata_parsed == 0) { bmdata_parsed = 1; timediff = 0; if (fgets(line, 50, fp)) { sscanf(line, "%d", &last_bm_save_time); gettimeofday(&tv, NULL); timediff = (int)tv.tv_sec - last_bm_save_time; if (timediff < 0) timediff = 0; while (fgets(line, 50, fp)) { spot *entry = g_new0(spot, 1); fc = 0; token = strtok (line, ";"); while (token != NULL) { switch(fc) { case 0: entry -> call = g_strdup(token); break; case 1: sscanf(token, "%d", &entry->freq); break; case 2: sscanf(token, "%hhd", &entry->mode); break; case 3: sscanf(token, "%hd", &entry->band); break; case 4: sscanf(token, "%c", &entry->node); break; case 5: sscanf(token, "%u", &entry->timeout); break; case 6: sscanf(token, "%hhd", &entry->dupe); break; } fc++; token = strtok (NULL, ";"); } if (entry->timeout > timediff) { entry->timeout -= timediff; /* remaining time */ allspots = g_list_insert_sorted( allspots, entry, (GCompareFunc)cmp_freq); } else { g_free(entry); } } } fclose(fp); } }
/* * Build sorted list of email items. * Enter: list List of E-Mail items to sorted. * Return: Sorted list. * Note: List should freed after use. Items referenced by list should not be * freed since they are managed by the address cache. */ static GList *exporthtml_sort_email( const GList *list ) { const GList *node; GList *sorted = NULL; node = list; while( node ) { sorted = g_list_insert_sorted( sorted, node->data, exporthtml_compare_email ); node = g_list_next( node ); } return sorted; }
void egg_toolbar_editor_add_action (EggToolbarEditor *editor, const char *action_name) { GtkAction *action; action = find_action (editor, action_name); g_return_if_fail (action != NULL); editor->priv->default_actions_list = g_list_insert_sorted (editor->priv->default_actions_list, action, compare_actions); }
GList * empathy_log_manager_get_dates (EmpathyLogManager *manager, McAccount *account, const gchar *chat_id, gboolean chatroom) { GList *dates = NULL; gchar *date; gchar *directory; GDir *dir; const gchar *filename; const gchar *p; g_return_val_if_fail (EMPATHY_IS_LOG_MANAGER (manager), NULL); g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL); g_return_val_if_fail (chat_id != NULL, NULL); directory = log_manager_get_dir (manager, account, chat_id, chatroom); dir = g_dir_open (directory, 0, NULL); if (!dir) { DEBUG ("Could not open directory:'%s'", directory); g_free (directory); return NULL; } DEBUG ("Collating a list of dates in:'%s'", directory); while ((filename = g_dir_read_name (dir)) != NULL) { if (!g_str_has_suffix (filename, LOG_FILENAME_SUFFIX)) { continue; } p = strstr (filename, LOG_FILENAME_SUFFIX); date = g_strndup (filename, p - filename); if (!date) { continue; } if (!g_regex_match_simple ("\\d{8}", date, 0, 0)) { continue; } dates = g_list_insert_sorted (dates, date, (GCompareFunc) strcmp); } g_free (directory); g_dir_close (dir); DEBUG ("Parsed %d dates", g_list_length (dates)); return dates; }
gboolean vp_keys_foreach(const gchar *name, const gchar *value, gpointer user_data) { gpointer *args = (gpointer *) user_data; GList **keys = (GList **) args[0]; gboolean *test_key_found = (gboolean *) args[1]; if (strcmp(name, "test.key") != 0) *keys = g_list_insert_sorted(*keys, g_strdup(name), (GCompareFunc) strcmp); else *test_key_found = TRUE; return FALSE; }
static bool view_main_wifi_found_ap_cb(wifi_ap_h ap, void* user_data) { int *profile_size = (int *)user_data; wifi_device_info_t *wifi_device = NULL; wifi_device = view_main_item_device_info_create(ap); if (wifi_device == NULL) return true; wifi_device_list = g_list_insert_sorted(wifi_device_list, wifi_device, compare); (*profile_size)++; return true; }
gboolean gst_media_descriptor_get_buffers (GstMediaDescriptor * self, GstPad * pad, GCompareFunc compare_func, GList ** bufs) { GList *tmpstream, *tmpframe; gboolean check = (pad == NULL), ret = FALSE; GstCaps *pad_caps = gst_pad_get_current_caps (pad); g_return_val_if_fail (GST_IS_MEDIA_DESCRIPTOR (self), FALSE); g_return_val_if_fail (self->filenode, FALSE); for (tmpstream = self->filenode->streams; tmpstream; tmpstream = tmpstream->next) { StreamNode *streamnode = (StreamNode *) tmpstream->data; if (pad && streamnode->pad == pad) check = TRUE; if (!streamnode->pad && gst_caps_is_subset (pad_caps, streamnode->caps)) { check = TRUE; } if (check) { ret = TRUE; for (tmpframe = streamnode->frames; tmpframe; tmpframe = tmpframe->next) { if (compare_func) *bufs = g_list_insert_sorted (*bufs, gst_buffer_ref (((FrameNode *) tmpframe->data)->buf), compare_func); else *bufs = g_list_prepend (*bufs, gst_buffer_ref (((FrameNode *) tmpframe->data)->buf)); } if (pad != NULL) goto done; } } done: if (compare_func == NULL) *bufs = g_list_reverse (*bufs); gst_caps_unref (pad_caps); return ret; }
/* * AddMountain * * Add a mountain peak to the list we use to keep track * of the mountain peaks. */ GList *AddMountain (GList *mountainList, int peakx, int peaky) { typMountain *node; node = (typMountain *) g_malloc (sizeof (typMountain)); node->start.x = peakx - peaky; node->start.y = 0; node->peak.x = peakx; node->peak.y = peaky; node->end.x = peakx + peaky; node->end.y = 0; return (g_list_insert_sorted (mountainList, node, (GCompareFunc)MountainCompare)); }
GList *collection_list_add(GList *list, CollectInfo *ci, SortType method) { if (method != SORT_NONE) { collection_list_sort_method = method; list = g_list_insert_sorted(list, ci, collection_list_sort_cb); } else { list = g_list_append(list, ci); } return list; }
/* * sels_copy (sels) * * returns a copy of sels */ GList * sels_copy (GList * sels) { GList * gl, * nsels = NULL; sw_sel * sel, * nsel; for (gl = sels; gl; gl = gl->next) { sel = (sw_sel *)gl->data; nsel = sel_copy (sel); nsels = g_list_insert_sorted(nsels, nsel, (GCompareFunc)sel_cmp); } return nsels; }
MetaFile * metafile_new (const char *name, MetaFile *parent) { MetaFile *f; f = g_new0 (MetaFile, 1); f->name = g_strdup (name); if (parent) parent->children = g_list_insert_sorted (parent->children, f, compare_metafile); return f; }
static MetaData * metadata_new (const char *key, MetaFile *file) { MetaData *data; data = g_new0 (MetaData, 1); data->key = g_strdup (key); if (file) file->data = g_list_insert_sorted (file->data, data, compare_metadata); return data; }
void Applier::AddPropertyChange (DependencyObject *object, DependencyProperty *property, Value *v, int precedence) { if (readonly) { g_warning ("Applier::AddPropertyChange is being called during shutdown"); delete v; return; } if (precedence == APPLIER_PRECEDENCE_INSTANT) { object->SetValue (property, *v); delete v; return; } value_indexer *v_indexer = NULL; property_indexer *p_indexer = NULL; object_indexer *o_indexer = NULL; if (!objects) objects = g_hash_table_new (g_direct_hash, g_direct_equal); else o_indexer = (object_indexer *) g_hash_table_lookup (objects, object); if (o_indexer == NULL) { o_indexer = g_new (object_indexer, 1); o_indexer->object = object; object->AddHandler (EventObject::DestroyedEvent, EventObject::ClearWeakRef, &o_indexer->object); o_indexer->properties_list = NULL; g_hash_table_insert (objects, object, o_indexer); } GList *list_item = g_list_find_custom (o_indexer->properties_list, property, (GCompareFunc) property_indexer_compare_func); if (list_item != NULL) p_indexer = (property_indexer *) list_item->data; if (p_indexer == NULL) { p_indexer = g_new (property_indexer, 1); p_indexer->property = property; p_indexer->values_list = NULL; o_indexer->properties_list = g_list_append (o_indexer->properties_list, p_indexer); } v_indexer = g_new (value_indexer, 1); v_indexer->precedence = precedence; v_indexer->v = v; p_indexer->values_list = g_list_insert_sorted (p_indexer->values_list, v_indexer, (GCompareFunc) value_indexer_compare_func); }