void init_separator_panel(void *p)
{
Panel *panel = (Panel *)p;
// Make sure this is only done once if there are multiple items
if (panel->separator_list)
return;
// panel->separator_list is now a copy of the pointer panel_config.separator_list
// We make it a deep copy
panel->separator_list = g_list_copy_deep(panel_config.separator_list, NULL, NULL);
for (GList *l = panel->separator_list; l; l = l->next) {
Separator *separator = (Separator *)l->data;
if (!separator->area.bg)
separator->area.bg = &g_array_index(backgrounds, Background, 0);
separator->area.parent = p;
separator->area.panel = p;
snprintf(separator->area.name, sizeof(separator->area.name), "separator");
separator->area.size_mode = LAYOUT_FIXED;
separator->area.resize_needed = 1;
separator->area.on_screen = TRUE;
separator->area._resize = resize_separator;
separator->area._compute_desired_size = separator_compute_desired_size;
separator->area._draw_foreground = draw_separator;
instantiate_area_gradients(&separator->area);
}
}
GList *
ges_layer_get_clips (GESLayer * layer)
{
GESLayerClass *klass;
g_return_val_if_fail (GES_IS_LAYER (layer), NULL);
klass = GES_LAYER_GET_CLASS (layer);
if (klass->get_objects) {
return klass->get_objects (layer);
}
return g_list_sort (g_list_copy_deep (layer->priv->clips_start,
(GCopyFunc) gst_object_ref, NULL),
(GCompareFunc) element_start_compare);
}
void init_execp_panel(void *p)
{
Panel *panel = (Panel *)p;
// Make sure this is only done once if there are multiple items
if (panel->execp_list && ((Execp *)panel->execp_list->data)->frontend)
return;
// panel->execp_list is now a copy of the pointer panel_config.execp_list
// We make it a deep copy
panel->execp_list = g_list_copy_deep(panel_config.execp_list, create_execp_frontend, NULL);
for (GList *l = panel->execp_list; l; l = l->next) {
Execp *execp = l->data;
execp->area.bg = execp->backend->bg;
execp->area.paddingx = execp->backend->paddingx;
execp->area.paddingy = execp->backend->paddingy;
execp->area.paddingxlr = execp->backend->paddingxlr;
execp->area.parent = panel;
execp->area.panel = panel;
execp->area._dump_geometry = execp_dump_geometry;
execp->area._compute_desired_size = execp_compute_desired_size;
snprintf(execp->area.name,
sizeof(execp->area.name),
"Execp %s",
execp->backend->command ? execp->backend->command : "null");
execp->area._draw_foreground = draw_execp;
execp->area.size_mode = LAYOUT_FIXED;
execp->area._resize = resize_execp;
execp->area._get_tooltip_text = execp_get_tooltip;
execp->area._is_under_mouse = full_width_area_is_under_mouse;
execp->area.has_mouse_press_effect =
panel_config.mouse_effects &&
(execp->area.has_mouse_over_effect = execp->backend->lclick_command || execp->backend->mclick_command ||
execp->backend->rclick_command || execp->backend->uwheel_command ||
execp->backend->dwheel_command);
execp->area.resize_needed = TRUE;
execp->area.on_screen = TRUE;
instantiate_area_gradients(&execp->area);
if (!execp->backend->timer)
execp->backend->timer = add_timeout(10, 0, execp_timer_callback, execp, &execp->backend->timer);
}
}
static void
photos_delete_notification_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
PhotosDeleteNotification *self = PHOTOS_DELETE_NOTIFICATION (object);
switch (prop_id)
{
case PROP_ITEMS:
{
GList *items;
items = (GList *) g_value_get_pointer (value);
self->items = g_list_copy_deep (items, (GCopyFunc) g_object_ref, NULL);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static ClosedTab *
closed_tab_new (GQueue *closed_tabs,
const char *address,
GList *bflist,
int position,
EphyNotebook *parent_notebook)
{
ClosedTab *tab = g_slice_new0 (ClosedTab);
ClosedTab *sibling_tab;
tab->url = g_strdup (address);
#ifndef HAVE_WEBKIT2
tab->bflist = g_list_copy_deep (bflist, (GCopyFunc)webkit_web_history_item_copy, NULL);
#endif
tab->position = position;
sibling_tab = find_tab_with_notebook (closed_tabs, parent_notebook);
if (sibling_tab)
tab->parent_location = sibling_tab->parent_location;
else
tab->parent_location = parent_location_new (parent_notebook);
return tab;
}
void
ags_midi_get_property(GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *param_spec)
{
AgsMidi *midi;
pthread_mutex_t *midi_mutex;
midi = AGS_MIDI(gobject);
/* get midi mutex */
pthread_mutex_lock(ags_midi_get_class_mutex());
midi_mutex = midi->obj_mutex;
pthread_mutex_unlock(ags_midi_get_class_mutex());
switch(prop_id){
case PROP_AUDIO:
{
pthread_mutex_lock(midi_mutex);
g_value_set_object(value, midi->audio);
pthread_mutex_unlock(midi_mutex);
}
break;
case PROP_AUDIO_CHANNEL:
{
pthread_mutex_lock(midi_mutex);
g_value_set_uint(value, midi->audio_channel);
pthread_mutex_unlock(midi_mutex);
}
break;
case PROP_TIMESTAMP:
{
pthread_mutex_lock(midi_mutex);
g_value_set_object(value, midi->timestamp);
pthread_mutex_unlock(midi_mutex);
}
break;
case PROP_TRACK:
{
pthread_mutex_lock(midi_mutex);
g_value_set_pointer(value, g_list_copy_deep(midi->track,
(GCopyFunc) g_object_ref,
NULL));
pthread_mutex_unlock(midi_mutex);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
void
ags_pulse_client_get_property(GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *param_spec)
{
AgsPulseClient *pulse_client;
pthread_mutex_t *pulse_client_mutex;
pulse_client = AGS_PULSE_CLIENT(gobject);
/* get pulse client mutex */
pthread_mutex_lock(ags_pulse_client_get_class_mutex());
pulse_client_mutex = pulse_client->obj_mutex;
pthread_mutex_unlock(ags_pulse_client_get_class_mutex());
switch(prop_id){
case PROP_PULSE_SERVER:
{
pthread_mutex_lock(pulse_client_mutex);
g_value_set_object(value, pulse_client->pulse_server);
pthread_mutex_unlock(pulse_client_mutex);
}
break;
case PROP_CLIENT_NAME:
{
pthread_mutex_lock(pulse_client_mutex);
g_value_set_string(value, pulse_client->client_name);
pthread_mutex_unlock(pulse_client_mutex);
}
break;
case PROP_DEVICE:
{
pthread_mutex_lock(pulse_client_mutex);
g_value_set_pointer(value,
g_list_copy_deep(pulse_client->device,
(GCopyFunc) g_object_ref,
NULL));
pthread_mutex_unlock(pulse_client_mutex);
}
break;
case PROP_PORT:
{
pthread_mutex_lock(pulse_client_mutex);
g_value_set_pointer(value,
g_list_copy_deep(pulse_client->port,
(GCopyFunc) g_object_ref,
NULL));
pthread_mutex_unlock(pulse_client_mutex);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
/**
* g_list_copy:
* @list: a #GList, this must point to the top of the list
*
* Copies a #GList.
*
* Note that this is a "shallow" copy. If the list elements
* consist of pointers to data, the pointers are copied but
* the actual data is not. See g_list_copy_deep() if you need
* to copy the data as well.
*
* Returns: the start of the new list that holds the same data as @list
*/
GList *
g_list_copy (GList *list)
{
return g_list_copy_deep (list, NULL, NULL);
}
/**
* Process the file that is not already in our local cache
* @param main_struct : main structure of the program
* @param meta is the meta data of the file to be processed (it does
* not contain any hashs at that point).
*/
static void process_big_file_not_in_cache(main_struct_t *main_struct, meta_data_t *meta)
{
GFile *a_file = NULL;
gchar *answer = NULL;
GFileInputStream *stream = NULL;
GError *error = NULL;
GList *hash_data_list = NULL;
GList *hdl_copy = NULL;
GList *saved_list = NULL;
hash_data_t *hash_data = NULL;
gssize read = 0;
guchar *buffer = NULL;
GChecksum *checksum = NULL;
guint8 *a_hash = NULL;
gsize digest_len = HASH_LEN;
gsize read_bytes = 0;
a_clock_t *elapsed = NULL;
if (main_struct != NULL && main_struct->opt != NULL && meta != NULL)
{
a_file = g_file_new_for_path(meta->name);
print_debug(_("Processing file: %s\n"), meta->name);
if (a_file != NULL)
{
stream = g_file_read(a_file, NULL, &error);
if (stream != NULL && error == NULL)
{
checksum = g_checksum_new(G_CHECKSUM_SHA256);
buffer = (guchar *) g_malloc(meta->blocksize);
a_hash = (guint8 *) g_malloc(digest_len);
read = g_input_stream_read((GInputStream *) stream, buffer, meta->blocksize, NULL, &error);
read_bytes = read_bytes + read;
while (read != 0 && error == NULL)
{
g_checksum_update(checksum, buffer, read);
g_checksum_get_digest(checksum, a_hash, &digest_len);
/* Need to save 'data', 'read' and digest hash in an hash_data_t structure */
hash_data = new_hash_data_t(buffer, read, a_hash);
hash_data_list = g_list_prepend(hash_data_list, hash_data);
g_checksum_reset(checksum);
digest_len = HASH_LEN;
if (read_bytes >= main_struct->opt->buffersize)
{
elapsed = new_clock_t();
print_debug(_("Sending data: %d bytes\n"), read_bytes);
/* 0. Save the list in order to keep hashs for meta-data */
hdl_copy = g_list_copy_deep(hash_data_list, copy_only_hash, NULL);
saved_list = g_list_concat(hdl_copy, saved_list);
/* 1. Send an array of hashs to Hash_Array.json server url */
answer = send_hash_array_to_server(main_struct->comm, hash_data_list);
/* 2. Keep only hashs that are needed (answer from the server) */
hash_data_list = send_all_data_to_server(main_struct, hash_data_list, answer);
/* 3. free memory of this list if any is left */
g_list_free_full(hash_data_list, free_hdt_struct);
hash_data_list = NULL;
read_bytes = 0;
end_clock(elapsed, "process_big_file_not_in_cache");
}
buffer = (guchar *) g_malloc(meta->blocksize);
a_hash = (guint8 *) g_malloc(digest_len);
read = g_input_stream_read((GInputStream *) stream, buffer, meta->blocksize, NULL, &error);
read_bytes = read_bytes + read;
}
if (error != NULL)
{
print_error(__FILE__, __LINE__, _("Error while reading file: %s\n"), error->message);
error = free_error(error);
g_list_free_full(hash_data_list, free_hdt_struct);
hash_data_list = NULL;
}
else
{
if (read_bytes > 0)
{
elapsed = new_clock_t();
print_debug(_("Sending data: %d bytes\n"), read_bytes);
/* 0. Save the list in order to keep hashs for meta-data */
hdl_copy = g_list_copy_deep(hash_data_list, copy_only_hash, NULL);
saved_list = g_list_concat(hdl_copy, saved_list);
/* 1. Send an array of hashs to Hash_Array.json server url */
answer = send_hash_array_to_server(main_struct->comm, hash_data_list);
/* 2. Keep only hashs that are needed (answer from the server) */
hash_data_list = send_all_data_to_server(main_struct, hash_data_list, answer);
/* 3. free memory of this list if any is left */
g_list_free_full(hash_data_list, free_hdt_struct);
hash_data_list = NULL;
read_bytes = 0;
end_clock(elapsed, "process_big_file_not_in_cache");
}
/* get the list in correct order (because we prepended the hashs to get speed when inserting hashs in the list) */
saved_list = g_list_reverse(saved_list);
}
free_variable(buffer);
free_variable(a_hash);
g_checksum_free(checksum);
g_input_stream_close((GInputStream *) stream, NULL, NULL);
free_object(stream);
}
else
{
print_error(__FILE__, __LINE__, _("Unable to open file for reading: %s\n"), error->message);
error = free_error(error);
}
meta->hash_data_list = saved_list;
answer = send_meta_data_to_server(main_struct, meta, TRUE);
if (answer != NULL)
{ /** @todo may be we should check that answer is something that tells that everything went Ok. */
/* Everything has been transmitted so we can save meta data into the local db cache */
/* This is usefull for file carving to avoid sending too much things to the server */
elapsed = new_clock_t();
db_save_meta_data(main_struct->database, meta, TRUE);
end_clock(elapsed, "db_save_meta_data");
}
a_file = free_object(a_file);
}
}
}
void
ags_recycling_context_get_property(GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *param_spec)
{
AgsRecyclingContext *recycling_context;
pthread_mutex_t *recycling_context_mutex;
recycling_context = AGS_RECYCLING_CONTEXT(gobject);
/* get recycling context mutex */
pthread_mutex_lock(ags_recycling_context_get_class_mutex());
recycling_context_mutex = recycling_context->obj_mutex;
pthread_mutex_unlock(ags_recycling_context_get_class_mutex());
switch(prop_id){
case PROP_RECALL_ID:
{
pthread_mutex_lock(recycling_context_mutex);
g_value_set_object(value, recycling_context->recall_id);
pthread_mutex_unlock(recycling_context_mutex);
}
break;
case PROP_PARENT:
{
pthread_mutex_lock(recycling_context_mutex);
g_value_set_object(value, recycling_context->parent);
pthread_mutex_unlock(recycling_context_mutex);
}
break;
case PROP_CHILD:
{
pthread_mutex_lock(recycling_context_mutex);
g_value_set_pointer(value, g_list_copy_deep(recycling_context->children,
(GCopyFunc) g_object_ref,
NULL));
pthread_mutex_unlock(recycling_context_mutex);
}
break;
case PROP_LENGTH:
{
pthread_mutex_lock(recycling_context_mutex);
g_value_set_uint64(value, recycling_context->length);
pthread_mutex_unlock(recycling_context_mutex);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
static GList *
facebook_image_list_copy (GList *source)
{
return g_list_copy_deep (source, (GCopyFunc) facebook_image_copy, NULL);
}
void
gtk_source_completion_model_set_visible_providers (GtkSourceCompletionModel *model,
GList *providers)
{
GList *l;
g_return_if_fail (GTK_SOURCE_IS_COMPLETION_MODEL (model));
for (l = providers; l != NULL; l = l->next)
{
g_return_if_fail (GTK_SOURCE_IS_COMPLETION_PROVIDER (l->data));
}
g_list_free_full (model->priv->visible_providers, g_object_unref);
model->priv->visible_providers = g_list_copy_deep (providers,
provider_copy_func,
NULL);
for (l = model->priv->providers; l != NULL; l = l->next)
{
ProviderInfo *provider_info = l->data;
provider_info->visible = is_provider_visible (model, provider_info->completion_provider);
}
}
static void callback_merger(GList *list, CallbackMergeContext *context)
{
g_mutex_lock(&context->mutex);
context->list = g_list_concat(context->list,
g_list_copy_deep (list, context->item_copy, context));
g_mutex_unlock(&context->mutex);
}
void
http_dd_set_headers(LogDriver *d, GList *headers)
{
HTTPDestinationDriver *self = (HTTPDestinationDriver *) d;
g_list_free_full(self->headers, g_free);
self->headers = g_list_copy_deep(headers, ((GCopyFunc)g_strdup), NULL);
}
static GList *
get_volumes (GVolumeMonitor *volume_monitor)
{
GUnixVolumeMonitor *monitor;
monitor = G_UNIX_VOLUME_MONITOR (volume_monitor);
return g_list_copy_deep (monitor->volumes, (GCopyFunc) g_object_ref, NULL);
}
GList *
gst_validate_runner_get_reports (GstValidateRunner * runner)
{
GList *ret;
GST_VALIDATE_RUNNER_LOCK (runner);
ret =
g_list_copy_deep (runner->priv->reports,
(GCopyFunc) gst_validate_report_ref, NULL);
GST_VALIDATE_RUNNER_UNLOCK (runner);
return ret;
}
GList *
kms_sdp_group_manager_get_groups (KmsSdpGroupManager * obj)
{
GList *groups, *ret = NULL;
g_return_val_if_fail (KMS_IS_SDP_GROUP_MANAGER (obj), NULL);
groups = g_hash_table_get_values (obj->priv->groups);
ret = g_list_copy_deep (groups, (GCopyFunc) g_object_ref, NULL);
g_list_free (groups);
return ret;
}
/**
* gssdp_resource_group_add_resource:
* @resource_group: A #GSSDPResourceGroup
* @target: The resource's target
* @usn: The resource's USN
* @locations: (element-type utf8): A #GList of the resource's locations
*
* Adds a resource with target @target, USN @usn, and locations @locations
* to @resource_group.
*
* Return value: The ID of the added resource.
**/
guint
gssdp_resource_group_add_resource (GSSDPResourceGroup *resource_group,
const char *target,
const char *usn,
GList *locations)
{
GSSDPResourceGroupPrivate *priv = NULL;
Resource *resource = NULL;
GError *error = NULL;
g_return_val_if_fail (GSSDP_IS_RESOURCE_GROUP (resource_group), 0);
g_return_val_if_fail (target != NULL, 0);
g_return_val_if_fail (usn != NULL, 0);
g_return_val_if_fail (locations != NULL, 0);
priv = gssdp_resource_group_get_instance_private (resource_group);
resource = g_slice_new0 (Resource);
resource->resource_group = resource_group;
resource->target = g_strdup (target);
resource->usn = g_strdup (usn);
resource->target_regex = create_target_regex (target,
&resource->version,
&error);
if (error) {
g_warning ("Error compiling regular expression for '%s': %s",
target,
error->message);
g_error_free (error);
resource_free (resource);
return 0;
}
resource->initial_byebye_sent = FALSE;
resource->locations = g_list_copy_deep (locations, (GCopyFunc) g_strdup, NULL);
priv->resources = g_list_prepend (priv->resources, resource);
resource->id = ++priv->last_resource_id;
if (priv->available)
resource_alive (resource);
return resource->id;
}
static void
photos_fetch_collection_state_job_job_collector (GList *collections_for_item, gpointer user_data)
{
PhotosFetchCollectionStateJobData *data = user_data;
PhotosFetchCollectionStateJob *self = data->job;
const gchar *urn = data->urn;
g_hash_table_insert (self->collections_for_items,
g_strdup (urn),
g_list_copy_deep (collections_for_item, (GCopyFunc) g_strdup, NULL));
self->running_jobs--;
if (self->running_jobs == 0)
photos_fetch_collection_state_job_emit_callback (self);
photos_fetch_collection_state_job_data_free (data);
}
void
ags_recall_dssi_run_get_property(GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *param_spec)
{
AgsRecallDssiRun *recall_dssi_run;
pthread_mutex_t *recall_mutex;
recall_dssi_run = AGS_RECALL_DSSI_RUN(gobject);
/* get recall mutex */
pthread_mutex_lock(ags_recall_get_class_mutex());
recall_mutex = AGS_RECALL(gobject)->obj_mutex;
pthread_mutex_unlock(ags_recall_get_class_mutex());
switch(prop_id){
case PROP_ROUTE_DSSI_AUDIO_RUN:
{
pthread_mutex_lock(recall_mutex);
g_value_set_object(value, recall_dssi_run->route_dssi_audio_run);
pthread_mutex_unlock(recall_mutex);
}
break;
case PROP_NOTE:
{
pthread_mutex_lock(recall_mutex);
g_value_set_pointer(value,
g_list_copy_deep(recall_dssi_run->note,
(GCopyFunc) g_object_ref,
NULL));
pthread_mutex_unlock(recall_mutex);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
};
}