static GstMpegtsAtscVCT *
_gst_mpegts_atsc_vct_copy (GstMpegtsAtscVCT * vct)
{
GstMpegtsAtscVCT *copy;
copy = g_slice_dup (GstMpegtsAtscVCT, vct);
copy->sources = g_ptr_array_ref (vct->sources);
copy->descriptors = g_ptr_array_ref (vct->descriptors);
return copy;
}
static GstMpegtsAtscMGT *
_gst_mpegts_atsc_mgt_copy (GstMpegtsAtscMGT * mgt)
{
GstMpegtsAtscMGT *copy;
copy = g_slice_dup (GstMpegtsAtscMGT, mgt);
copy->tables = g_ptr_array_ref (mgt->tables);
copy->descriptors = g_ptr_array_ref (mgt->descriptors);
return copy;
}
static GstMpegtsAtscEITEvent *
_gst_mpegts_atsc_eit_event_copy (GstMpegtsAtscEITEvent * event)
{
GstMpegtsAtscEITEvent *copy;
copy = g_slice_dup (GstMpegtsAtscEITEvent, event);
copy->titles = g_ptr_array_ref (event->titles);
copy->descriptors = g_ptr_array_ref (event->descriptors);
return copy;
}
void
g_graph_undirected_multi_edge_set_nodes(GGraphUndirectedMultiEdge* undirected_multi_edge,
GPtrArray* nodes)
{
GPtrArray* old;
g_return_if_fail(G_IS_GRAPH_UNDIRECTED_MULTI_EDGE(undirected_multi_edge));
old = undirected_multi_edge->priv->nodes;
if (old == nodes || ((!nodes || !nodes->len) && (!old || !old->len)))
{
return;
}
if (nodes)
{
undirected_multi_edge->priv->nodes = g_ptr_array_ref(nodes);
}
else
{
undirected_multi_edge->priv->nodes = g_ptr_array_new_with_free_func(g_object_unref);
}
if (old)
{
g_ptr_array_unref(old);
}
g_object_notify(undirected_multi_edge, "nodes");
}
static gboolean
gbp_cmake_toolchain_provider_load_finish (IdeToolchainProvider *provider,
GAsyncResult *result,
GError **error)
{
GbpCMakeToolchainProvider *self = (GbpCMakeToolchainProvider *)provider;
g_autoptr(GPtrArray) toolchains = NULL;
g_assert (IDE_IS_MAIN_THREAD ());
g_assert (GBP_IS_CMAKE_TOOLCHAIN_PROVIDER (self));
g_assert (IDE_IS_TASK (result));
g_assert (ide_task_is_valid (IDE_TASK (result), provider));
toolchains = ide_task_propagate_pointer (IDE_TASK (result), error);
if (toolchains == NULL)
return FALSE;
g_clear_pointer (&self->toolchains, g_ptr_array_unref);
self->toolchains = g_ptr_array_ref (toolchains);
for (guint i = 0; i < toolchains->len; i++)
{
IdeToolchain *toolchain = g_ptr_array_index (toolchains, i);
g_assert (IDE_IS_TOOLCHAIN (toolchain));
ide_toolchain_provider_emit_added (provider, toolchain);
}
return TRUE;
}
void
ol_scroll_window_set_whole_lyrics (OlScrollWindow *scroll,
GPtrArray *whole_lyrics)
{
ol_log_func ();
ol_assert (OL_IS_SCROLL_WINDOW (scroll));
OlScrollWindowPrivate *priv = OL_SCROLL_WINDOW_GET_PRIVATE (scroll);
if (scroll->whole_lyrics != NULL)
g_ptr_array_unref (scroll->whole_lyrics);
scroll->whole_lyrics = whole_lyrics;
if (whole_lyrics != NULL)
{
g_ptr_array_ref (whole_lyrics);
priv->saved_lrc_y = -1;
}
else
{
/* We only queue draw when the lyrics are no available.
Otherwise the progress will go wrong due to out-dated
progress info*/
gtk_widget_queue_draw (GTK_WIDGET (scroll));
}
ol_scroll_window_update_tooltip (scroll);
if (priv->seeking)
ol_scroll_window_end_seek (scroll);
}
static WritebackData *
writeback_data_new (TrackerController *controller,
GList *writeback_handlers,
TrackerSparqlConnection *connection,
const gchar *subject,
GPtrArray *results,
GDBusMethodInvocation *invocation,
TrackerDBusRequest *request)
{
WritebackData *data;
data = g_slice_new (WritebackData);
data->cancellable = g_cancellable_new ();
data->controller = g_object_ref (controller);
data->subject = g_strdup (subject);
data->results = g_ptr_array_ref (results);
data->invocation = invocation;
data->connection = g_object_ref (connection);
data->writeback_handlers = writeback_handlers;
data->request = request;
data->error = NULL;
data->cancel_id = g_cancellable_connect (data->cancellable,
G_CALLBACK (task_cancellable_cancelled_cb),
data, NULL);
return data;
}
static void
egg_task_cache_propagate_error (EggTaskCache *self,
gconstpointer key,
const GError *error)
{
GPtrArray *queued;
g_assert (EGG_IS_TASK_CACHE (self));
g_assert (error != NULL);
if ((queued = g_hash_table_lookup (self->queued, key)))
{
gint64 count = queued->len;
gsize i;
/* we can't use steal because we want the key freed */
g_ptr_array_ref (queued);
g_hash_table_remove (self->queued, key);
for (i = 0; i < queued->len; i++)
{
GTask *task;
task = g_ptr_array_index (queued, i);
g_task_return_error (task, g_error_copy (error));
}
g_ptr_array_unref (queued);
EGG_COUNTER_SUB (queued, count);
}
}
static void
egg_task_cache_propagate_pointer (EggTaskCache *self,
gconstpointer key,
gpointer value)
{
GPtrArray *queued = NULL;
g_assert (EGG_IS_TASK_CACHE (self));
if ((queued = g_hash_table_lookup (self->queued, key)))
{
gint64 count = queued->len;
gsize i;
g_ptr_array_ref (queued);
g_hash_table_remove (self->queued, key);
for (i = 0; i < queued->len; i++)
{
GTask *task;
task = g_ptr_array_index (queued, i);
g_task_return_pointer (task,
self->value_copy_func (value),
self->value_destroy_func);
}
g_ptr_array_unref (queued);
EGG_COUNTER_SUB (queued, count);
}
}
Sample*
sample_dup(Sample* s)
{
Sample* r = g_new0(Sample, 1);
r->id = s->id;
r->ref_count = 0;
r->sample_rate = s->sample_rate;
r->length = s->length;
r->frames = s->frames;
r->channels = s->channels;
r->bit_depth = s->bit_depth;
r->bit_rate = s->bit_rate;
r->peaklevel = s->peaklevel;
r->colour_index = s->colour_index;
r->online = s->online;
r->mtime = s->mtime;
#define DUPSTR(P) if (s->P) r->P = strdup(s->P);
DUPSTR(sample_dir)
DUPSTR(name)
DUPSTR(full_path)
DUPSTR(keywords)
DUPSTR(ebur)
DUPSTR(notes)
DUPSTR(mimetype)
r->meta_data = s->meta_data ? g_ptr_array_ref(s->meta_data) : NULL;
if (s->overview) r->overview = gdk_pixbuf_copy(s->overview);
sample_ref(r);
return r;
}
/**
* g_usb_context_get_devices:
* @context: a #GUsbContext
*
* Return value: (transfer full) (element-type GUsbDevice): a new #GPtrArray of #GUsbDevice's.
*
* Since: 0.2.2
**/
GPtrArray *
g_usb_context_get_devices (GUsbContext *context)
{
g_return_val_if_fail (G_USB_IS_CONTEXT (context), NULL);
g_usb_context_enumerate (context);
return g_ptr_array_ref (context->priv->devices);
}
static GPtrArray *
ide_mingw_device_provider_get_devices (IdeDeviceProvider *provider)
{
IdeMingwDeviceProvider *self = (IdeMingwDeviceProvider *)provider;
g_return_val_if_fail (IDE_IS_MINGW_DEVICE_PROVIDER (self), NULL);
return g_ptr_array_ref (self->devices);
}
void
symbol_db_system_parse_aborted_package (SymbolDBSystem *sdbs,
GPtrArray *files_to_scan_array,
GPtrArray *languages_array)
{
SymbolDBSystemPriv *priv;
EngineScanData *es_data;
g_return_if_fail (sdbs != NULL);
g_return_if_fail (files_to_scan_array != NULL);
g_return_if_fail (languages_array != NULL);
priv = sdbs->priv;
/* create a special EngineScanData */
es_data = g_new0 (EngineScanData, 1);
es_data->sdbs = sdbs;
es_data->cflags = NULL;
es_data->package_name = g_strdup (_("Resuming glb scan."));
es_data->special_abort_scan = TRUE;
es_data->files_to_scan_array = g_ptr_array_ref (files_to_scan_array);
es_data->languages_array = g_ptr_array_ref (languages_array);
DEBUG_PRINT ("SYSTEM ABORT PARSING.....");
/* is the engine queue already full && working? */
if (g_queue_get_length (priv->engine_queue) > 0)
{
/* just push the tail waiting for a later processing [i.e. after
* a scan-end received
*/
DEBUG_PRINT ("pushing on engine queue %s", es_data->package_name);
g_queue_push_tail (priv->engine_queue, es_data);
}
else
{
DEBUG_PRINT ("aborted package");
/* push the tail to signal a 'working engine' */
g_queue_push_tail (priv->engine_queue, es_data);
sdb_system_do_engine_scan (sdbs, es_data);
}
}
static GstMpegtsAtscSTT *
_gst_mpegts_atsc_stt_copy (GstMpegtsAtscSTT * stt)
{
GstMpegtsAtscSTT *copy;
copy = g_slice_dup (GstMpegtsAtscSTT, stt);
copy->descriptors = g_ptr_array_ref (stt->descriptors);
return copy;
}
static GstMpegtsAtscETT *
_gst_mpegts_atsc_ett_copy (GstMpegtsAtscETT * ett)
{
GstMpegtsAtscETT *copy;
copy = g_slice_dup (GstMpegtsAtscETT, ett);
copy->messages = g_ptr_array_ref (ett->messages);
return copy;
}
static GstMpegtsAtscMGTTable *
_gst_mpegts_atsc_mgt_table_copy (GstMpegtsAtscMGTTable * mgt_table)
{
GstMpegtsAtscMGTTable *copy;
copy = g_slice_dup (GstMpegtsAtscMGTTable, mgt_table);
copy->descriptors = g_ptr_array_ref (mgt_table->descriptors);
return copy;
}
static GstMpegtsAtscEIT *
_gst_mpegts_atsc_eit_copy (GstMpegtsAtscEIT * eit)
{
GstMpegtsAtscEIT *copy;
copy = g_slice_dup (GstMpegtsAtscEIT, eit);
copy->events = g_ptr_array_ref (eit->events);
return copy;
}
static GstMpegtsAtscMultString *
_gst_mpegts_atsc_mult_string_copy (GstMpegtsAtscMultString * mstring)
{
GstMpegtsAtscMultString *copy;
copy = g_slice_dup (GstMpegtsAtscMultString, mstring);
copy->segments = g_ptr_array_ref (mstring->segments);
return copy;
}
/* Terrestrial/Cable Virtual Channel Table TVCT/CVCT */
static GstMpegtsAtscVCTSource *
_gst_mpegts_atsc_vct_source_copy (GstMpegtsAtscVCTSource * source)
{
GstMpegtsAtscVCTSource *copy;
copy = g_slice_dup (GstMpegtsAtscVCTSource, source);
copy->descriptors = g_ptr_array_ref (source->descriptors);
return copy;
}
/**
* qmi_client_ctl_get_version_info_finish:
* @res: a #GAsyncResult.
* @error: a #GError.
*
* Finishes an operation started with qmi_client_ctl_get_version_info().
*
* Returns: A #GPtrArray of #QmiCtlVersionInfo, or #NULL if @error is set.
*/
GPtrArray *
qmi_client_ctl_get_version_info_finish (QmiClientCtl *self,
GAsyncResult *res,
GError **error)
{
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
return NULL;
return g_ptr_array_ref (g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res)));
}
/**
* tp_base_media_call_stream_set_stun_servers:
* @self: a #TpBaseMediaCallStream
* @stun_servers: the new stun servers
*
* Set the STUN servers. The #GPtrArray should have a free_func defined such as
* g_ptr_array_ref() is enough to keep the data and g_ptr_array_unref() is
* enough to release it later.
*
* Note that this replaces the previously set STUN servers, it is not an
* addition.
*
* Since: 0.17.5
*/
void
tp_base_media_call_stream_set_stun_servers (TpBaseMediaCallStream *self,
GPtrArray *stun_servers)
{
g_return_if_fail (TP_IS_BASE_MEDIA_CALL_STREAM (self));
g_return_if_fail (stun_servers != NULL);
if (self->priv->stun_servers != NULL)
{
if (stun_servers->len == self->priv->stun_servers->len)
{
guint i;
gboolean equal = TRUE;
for (i = 0; i < stun_servers->len; i++)
{
GValueArray *gva1 = g_ptr_array_index (stun_servers, i);
GValueArray *gva2 = g_ptr_array_index (self->priv->stun_servers,
i);
gchar *ip1, *ip2;
guint port1, port2;
tp_value_array_unpack (gva1, 2, &ip1, &port1);
tp_value_array_unpack (gva2, 2, &ip2, &port2);
if (port1 != port2 || strcmp (ip1, ip2))
{
equal = FALSE;
break;
}
}
if (equal)
{
g_ptr_array_unref (stun_servers);
return;
}
}
g_ptr_array_unref (self->priv->stun_servers);
}
self->priv->stun_servers = g_ptr_array_ref (stun_servers);
tp_svc_call_stream_interface_media_emit_stun_servers_changed (self,
self->priv->stun_servers);
maybe_got_server_info (self);
}
/**
* mex_program_get_actors:
* @program: A #MexProgram
*
* Retrieves the #GPtrArray containing the actor names as strings. Call
* g_ptr_array_unref on the returned value once finished with.
*
* Return value: A #GPtrArray or NULL if there are no actors defined.
*/
GPtrArray *
mex_program_get_actors (MexProgram *program)
{
MexProgramPrivate *priv;
g_return_val_if_fail (MEX_IS_PROGRAM (program), NULL);
priv = program->priv;
if (priv->actors) {
return g_ptr_array_ref (priv->actors);
} else {
return NULL;
}
}
/**
* tp_base_media_call_stream_set_relay_info:
* @self: a #TpBaseMediaCallStream
* @relays: the new relays info
*
* Set the relays info. The #GPtrArray should have a free_func defined such as
* g_ptr_array_ref() is enough to keep the data and g_ptr_array_unref() is
* enough to release it later.
*
* Note that this replaces the previously set relays, it is not an addition.
*
* Since: 0.17.5
*/
void
tp_base_media_call_stream_set_relay_info (TpBaseMediaCallStream *self,
GPtrArray *relays)
{
g_return_if_fail (TP_IS_BASE_MEDIA_CALL_STREAM (self));
g_return_if_fail (relays != NULL);
tp_clear_pointer (&self->priv->relay_info, g_ptr_array_unref);
self->priv->relay_info = g_ptr_array_ref (relays);
tp_svc_call_stream_interface_media_emit_relay_info_changed (self,
self->priv->relay_info);
maybe_got_server_info (self);
}
static void
ostree_chain_input_stream_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
OstreeChainInputStream *self;
self = OSTREE_CHAIN_INPUT_STREAM (object);
switch (prop_id)
{
case PROP_STREAMS:
self->priv->streams = g_ptr_array_ref (g_value_get_pointer (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
sop_sax_path (GsfXMLIn *xin, xmlChar const **attrs)
{
SheetObject *so = gnm_xml_in_cur_obj (xin);
GnmSOPath *sop = GNM_SO_PATH (so);
GOPath *path;
g_return_if_fail (sop->path == NULL);
if (sop->paths == NULL)
sop->paths = g_ptr_array_new_with_free_func ((GDestroyNotify) go_path_free);
for (; attrs != NULL && attrs[0] && attrs[1] ; attrs += 2)
if (attr_eq (attrs[0], "Path")) {
path = go_path_new_from_svg (attrs[1]);
if (path)
g_ptr_array_add (sop->paths, path);
/* we need to update the extents, not optimal */
g_ptr_array_ref (sop->paths);
g_object_set (G_OBJECT (sop), "paths", sop->paths, NULL);
g_ptr_array_unref (sop->paths);
return;
}
}
void
salut_presence_cache_learn_caps (SalutPresenceCache *self,
const gchar *node,
const gchar *ver,
const GabbleCapabilitySet *caps,
const GPtrArray *data_forms)
{
SalutPresenceCachePrivate *priv;
CapabilityInfo *info;
gchar *tmp;
priv = SALUT_PRESENCE_CACHE_PRIV (self);
tmp = g_strdup_printf ("%s#%s", node, ver);
DEBUG ("learning %s\n", tmp);
info = g_slice_new0 (CapabilityInfo);
info->caps = gabble_capability_set_copy (caps);
info->data_forms = g_ptr_array_ref ((GPtrArray *) data_forms);
g_hash_table_insert (priv->capabilities, tmp, info);
}
static void
get_languages_in_thread_cb (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GPtrArray *result;
GError *error;
error = NULL;
result = gnlp_get_available_languages_sync (cancellable, &error);
if (error)
{
g_task_return_error (task, error);
return;
}
g_task_return_pointer (task,
g_ptr_array_ref (result),
(GDestroyNotify) g_ptr_array_unref);
}
/**
* gcm_trc_widget_set_property:
**/
static void
gcm_trc_widget_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
GcmTrcWidget *trc = GCM_TRC_WIDGET (object);
switch (prop_id) {
case PROP_USE_GRID:
trc->priv->use_grid = g_value_get_boolean (value);
break;
case PROP_DATA:
if (trc->priv->data != NULL)
g_ptr_array_unref (trc->priv->data);
trc->priv->data = g_ptr_array_ref (g_value_get_boxed (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
/* refresh widget */
gtk_widget_hide (GTK_WIDGET (trc));
gtk_widget_show (GTK_WIDGET (trc));
}
/**
* pk_package_sack_get_array:
* @sack: a valid #PkPackageSack instance
*
* Gets the package array from the sack
*
* Return value: (element-type PkPackage) (transfer container): A #GPtrArray, free with g_ptr_array_unref().
*
* Since: 0.6.1
**/
GPtrArray *
pk_package_sack_get_array (PkPackageSack *sack)
{
g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), NULL);
return g_ptr_array_ref (sack->priv->array);
}
static void
mail_to_event (ECalClientSourceType source_type,
gboolean with_attendees,
EMailReader *reader)
{
EShell *shell;
EMailBackend *backend;
ESourceRegistry *registry;
GPtrArray *uids;
ESource *source = NULL;
ESource *default_source;
GList *list, *iter;
GtkWindow *parent;
const gchar *extension_name;
parent = e_mail_reader_get_window (reader);
uids = e_mail_reader_get_selected_uids (reader);
/* Ask before converting 10 or more mails to events. */
if (uids->len > 10) {
gchar *question;
gint response;
question = g_strdup_printf (
get_question_add_all_mails (source_type, uids->len), uids->len);
response = do_ask (question, FALSE);
g_free (question);
if (response == GTK_RESPONSE_NO) {
g_ptr_array_unref (uids);
return;
}
}
backend = e_mail_reader_get_backend (reader);
shell = e_shell_backend_get_shell (E_SHELL_BACKEND (backend));
registry = e_shell_get_registry (shell);
switch (source_type) {
case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
extension_name = E_SOURCE_EXTENSION_CALENDAR;
default_source = e_source_registry_ref_default_calendar (registry);
break;
case E_CAL_CLIENT_SOURCE_TYPE_MEMOS:
extension_name = E_SOURCE_EXTENSION_MEMO_LIST;
default_source = e_source_registry_ref_default_memo_list (registry);
break;
case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
extension_name = E_SOURCE_EXTENSION_TASK_LIST;
default_source = e_source_registry_ref_default_task_list (registry);
break;
default:
g_return_if_reached ();
}
list = e_source_registry_list_sources (registry, extension_name);
/* If there is only one writable source, no need to prompt the user. */
for (iter = list; iter != NULL; iter = g_list_next (iter)) {
ESource *candidate = E_SOURCE (iter->data);
if (e_source_get_writable (candidate)) {
if (source == NULL)
source = candidate;
else {
source = NULL;
break;
}
}
}
g_list_free_full (list, (GDestroyNotify) g_object_unref);
if (source == NULL) {
GtkWidget *dialog;
ESourceSelector *selector;
/* ask the user which tasks list to save to */
dialog = e_source_selector_dialog_new (
parent, registry, extension_name);
selector = e_source_selector_dialog_get_selector (
E_SOURCE_SELECTOR_DIALOG (dialog));
e_source_selector_set_primary_selection (
selector, default_source);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
source = e_source_selector_dialog_peek_primary_selection (
E_SOURCE_SELECTOR_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
if (source) {
/* if a source has been selected, perform the mail2event operation */
AsyncData *data = NULL;
GThread *thread = NULL;
GError *error = NULL;
/* Fill the elements in AsynData */
data = g_new0 (AsyncData, 1);
data->client_cache = g_object_ref (e_shell_get_client_cache (shell));
data->source = g_object_ref (source);
data->extension_name = extension_name;
data->source_type = source_type;
data->folder = e_mail_reader_ref_folder (reader);
data->uids = g_ptr_array_ref (uids);
data->with_attendees = with_attendees;
if (uids->len == 1)
data->selected_text = get_selected_text (reader);
else
data->selected_text = NULL;
thread = g_thread_try_new (
NULL, (GThreadFunc) do_mail_to_event, data, &error);
if (error != NULL) {
g_warning (G_STRLOC ": %s", error->message);
g_error_free (error);
} else {
g_thread_unref (thread);
}
}
g_object_unref (default_source);
g_ptr_array_unref (uids);
}
