/**
* 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);
}
