RESULT ptrarray_remove() { GPtrArray *array; guint i; array = ptrarray_alloc_and_fill(&i); g_ptr_array_remove(array, (gpointer)items[7]); if(!g_ptr_array_remove(array, (gpointer)items[4])) { return FAILED("Item %s not removed", items[4]); } if(g_ptr_array_remove(array, (gpointer)items[4])) { return FAILED("Item %s still in array after removal", items[4]); } if(array->pdata[array->len - 1] != items[array->len + 1]) { return FAILED("Last item in GPtrArray not correct"); } g_ptr_array_free(array, TRUE); return OK; }
/** * pka_manager_remove_channel: * @context: A #PkaContext. * @channel: A #PkaChannel. * @error: A location for a #GError, or %NULL. * * Removes @channel from the Perfkit Agent. If the context does not have * permissions, the operation will fail. * * Returns: %TRUE if successful; otherwise %FALSE. * Side effects: None. */ gboolean pka_manager_remove_channel (PkaContext *context, /* IN */ PkaChannel *channel, /* IN */ GError **error) /* OUT */ { gint channel_id; g_return_val_if_fail(context != NULL, FALSE); g_return_val_if_fail(PKA_IS_CHANNEL(channel), FALSE); ENTRY; AUTHORIZE_IOCTL(context, REMOVE_CHANNEL); /* * TODO: * * 1) Ensure the channel is completely stopped. * 2) Ensure the channels sources are stopped. * 3) Notify the subscriptions the channel is gone. * 4) Notify the listeners the subscription is gone. * */ if (FALSE) { channel_id = pka_channel_get_id(channel); INFO(Channel, "Removing channel %d on behalf of context %d.", channel_id, pka_context_get_id(context)); G_LOCK(channels); g_ptr_array_remove(manager.channels, channel); G_UNLOCK(channels); NOTIFY_LISTENERS(channel_removed, channel_id); g_object_unref(channel); } RETURN(TRUE); }
/** * pka_manager_remove_source: * @context: A #PkaContext. * @source: A #PkaSource. * @error: A location for a #GError, or %NULL. * * Removes @source from the Perfkit Agent. If the context does not have * permissions, this operation will fail. * * Returns: %TRUE if successful; otherwise %FALSE. * Side effects: None. */ gboolean pka_manager_remove_source (PkaContext *context, /* IN */ PkaSource *source, /* IN */ GError **error) /* OUT */ { gboolean found; gint source_id; g_return_val_if_fail(context != NULL, FALSE); g_return_val_if_fail(PKA_IS_SOURCE(source), FALSE); ENTRY; AUTHORIZE_IOCTL(context, REMOVE_SOURCE); pka_source_notify_stopped(source); source_id = pka_source_get_id(source); INFO(Source, "Removing source %d on behalf of context %d.", source_id, pka_context_get_id(context)); G_LOCK(sources); found = g_ptr_array_remove(manager.sources, source); G_UNLOCK(sources); if (found) { NOTIFY_LISTENERS(source_removed, source_id); g_object_unref(source); } RETURN(found); }
/** * pka_manager_remove_encoder: * @context: A #PkaContext. * @encoder: A #PkaEncoder. * @error: A location for a #GError, or %NULL. * * Removes @encoder from the Perfkit Agent. If the context does not have * permissions, this operation will fail. * * Returns: %TRUE if succesful; otherwise %FALSE. * Side effects: None. */ gboolean pka_manager_remove_encoder (PkaContext *context, /* IN */ PkaEncoder *encoder, /* IN */ GError **error) /* OUT */ { gint encoder_id; g_return_val_if_fail(context != NULL, FALSE); g_return_val_if_fail(PKA_IS_ENCODER(encoder), FALSE); ENTRY; AUTHORIZE_IOCTL(context, REMOVE_ENCODER); /* * TODO: * * 1) Enure the encoder is not attached to a running channel. * */ if (FALSE) { encoder_id = pka_encoder_get_id(encoder); INFO(Encoder, "Removing encoder %d on behalf of context %d.", encoder_id, pka_context_get_id(context)); G_LOCK(encoders); g_ptr_array_remove(manager.encoders, encoder); G_UNLOCK(encoders); NOTIFY_LISTENERS(encoder_removed, encoder_id); g_object_unref(encoder); } RETURN(TRUE); }
void mc_event_del (const gchar * event_group_name, const gchar * event_name, mc_event_callback_func_t event_callback, gpointer event_init_data) { GTree *event_group; GPtrArray *callbacks; mc_event_callback_t *cb; if (mc_event_grouplist == NULL || event_group_name == NULL || event_name == NULL || event_callback == NULL) return; event_group = mc_event_get_event_group_by_name (event_group_name, FALSE, NULL); if (event_group == NULL) return; callbacks = mc_event_get_event_by_name (event_group, event_name, FALSE, NULL); if (callbacks == NULL) return; cb = mc_event_is_callback_in_array (callbacks, event_callback, event_init_data); if (cb == NULL) return; g_ptr_array_remove (callbacks, (gpointer) cb); g_free ((gpointer) cb); }
/** * atk_relation_set_remove: * @set: an #AtkRelationSet * @relation: an #AtkRelation * * Removes a relation from the relation set. * This function unref's the #AtkRelation so it will be deleted unless there * is another reference to it. **/ void atk_relation_set_remove (AtkRelationSet *set, AtkRelation *relation) { GPtrArray *array_item; AtkRelationType relationship; g_return_if_fail (ATK_IS_RELATION_SET (set)); array_item = set->relations; if (array_item == NULL) return; if (g_ptr_array_remove (array_item, relation)) { g_object_unref (relation); } else { relationship = atk_relation_get_relation_type (relation); if (atk_relation_set_contains (set, relationship)) { AtkRelation *exist_relation; gint i; exist_relation = atk_relation_set_get_relation_by_type (set, relationship); for (i = 0; i < relation->target->len; i++) { AtkObject *target = g_ptr_array_index(relation->target, i); atk_relation_remove_target (exist_relation, target); } } } }
gboolean my_timeline_model_remove_object (MyTimelineModel * self, gpointer object) { MyTimelineModelPrivate *priv = my_timeline_model_get_instance_private (self); g_return_if_fail (MY_IS_TIMELINE_MODEL (self)); if (MY_IS_SYSTEM (object)) { } else if (MY_IS_FLOW_ARROW (object)) { if (TIMELINE_MODEL_INDEX_IS_TRANSFER) { GPtrArray *transition; transition = g_ptr_array_index (priv->tl_arrows, TIMELINE_MODEL_CURRENT_INDEX); g_ptr_array_remove (transition, object); /*g_signal_emit (G_OBJECT (self), */ /*signals[SIG_ARROW_REMOVED_AT_CURRENT_INDEX], 0, */ /*object); */ } else { g_print ("can't remove arrow in a state\n"); return FALSE; } } return TRUE; }
static void mnp_clock_area_drop (MxDroppable *droppable, MxDraggable *draggable, gfloat event_x, gfloat event_y, gint button, ClutterModifierType modifiers) { ClutterActor *self = CLUTTER_ACTOR (droppable); ClutterActor *child = CLUTTER_ACTOR (draggable); MnpClockTile *tile = (MnpClockTile *)draggable; MnpClockArea *area = (MnpClockArea *)droppable; GPtrArray *tiles = area->priv->clock_tiles; int i, pos; g_object_ref (draggable); pos = (event_y) / 80; if (pos >= tiles->len) pos = tiles->len -1; clutter_actor_reparent (child, self); g_ptr_array_remove (tiles, (gpointer) draggable); insert_in_ptr_array (tiles, draggable, pos); clutter_actor_set_depth ((ClutterActor *)draggable, ((pos+1) * 0.05) - 0.01); for (i=tiles->len-1; i >= 0; i--) { clutter_actor_set_depth (tiles->pdata[i], (i + 1) * 0.05); } area->priv->zone_reorder_func(mnp_clock_tile_get_location(tile), pos, area->priv->zone_reorder_data); g_object_unref (draggable); }
/** * Detaches track from the smf. */ void smf_track_remove_from_smf(smf_track_t *track) { int i, j; smf_track_t *tmp; smf_event_t *ev; assert(track->smf != NULL); track->smf->number_of_tracks--; assert(track->smf->tracks_array); g_ptr_array_remove(track->smf->tracks_array, track); /* Renumber the rest of the tracks, so they are consecutively numbered. */ for (i = track->track_number; i <= track->smf->number_of_tracks; i++) { tmp = smf_get_track_by_number(track->smf, i); tmp->track_number = i; /* * Events have track numbers too. I guess this wasn't a wise * decision. ;-/ */ for (j = 1; j <= tmp->number_of_events; j++) { ev = smf_track_get_event_by_number(tmp, j); ev->track_number = i; } } track->track_number = -1; track->smf = NULL; }
static void tile_drag_run (MnpClockTile *tile, int ypos, MnpClockArea *area) { /*ClutterActor *self = CLUTTER_ACTOR (area); ClutterActor *child = CLUTTER_ACTOR (tile); */ GPtrArray *tiles = area->priv->clock_tiles; int i, pos; int diff = tiles->len == 4 ? 80 : 110; g_object_ref (tile); pos = (ypos-diff) / 80; if (pos >= tiles->len) pos = tiles->len -1; g_ptr_array_remove (tiles, (gpointer) tile); insert_in_ptr_array (tiles, tile, pos); clutter_actor_set_depth ((ClutterActor *)tile, ((pos+1) * 0.05) - 0.01); for (i=tiles->len-1; i >= 0; i--) { clutter_actor_set_depth (tiles->pdata[i], (i + 1) * 0.05); } g_object_unref (tile); }
/*! * \brief Create a copy of the whole diagram data * * This is kind of a deep copy, everything not immutable gets duplicated. * Still this is supposed to be relatively fast, because the most expensive * objects have immutuable properties, namely the pixbufs in DiaImage are * only referenced. * * \memberof _DiagramData */ DiagramData * diagram_data_clone (DiagramData *data) { DiagramData *clone; guint i; clone = g_object_new (DIA_TYPE_DIAGRAM_DATA, NULL); clone->extents = data->extents; clone->bg_color = data->bg_color; clone->paper = data->paper; /* so ugly */ clone->paper.name = g_strdup (data->paper.name); clone->is_compressed = data->is_compressed; layer_destroy(g_ptr_array_index(clone->layers, 0)); g_ptr_array_remove(clone->layers, clone->active_layer); for (i=0; i < data->layers->len; ++i) { Layer *src_layer = g_ptr_array_index(data->layers, i); Layer *dest_layer = new_layer (layer_get_name (src_layer), clone); /* copy layer, init the active one */ dest_layer->extents = src_layer->extents; dest_layer->objects = object_copy_list (src_layer->objects); dest_layer->visible = src_layer->visible; dest_layer->connectable = src_layer->connectable; g_ptr_array_add (clone->layers, dest_layer); if (src_layer == data->active_layer) clone->active_layer = dest_layer; /* the rest should be initialized by construction */ } return clone; }
static gboolean remove_color_to_names_sets (GstylePalette *self, GstyleColor *color) { const gchar *name; GPtrArray *set; gboolean ret = FALSE; g_assert (GSTYLE_IS_PALETTE (self)); g_assert (GSTYLE_IS_COLOR (color)); name = gstyle_color_get_name (color); if (gstyle_str_empty0 (name)) return FALSE; set = g_hash_table_lookup (self->color_names, name); if (set == NULL) return FALSE; ret = g_ptr_array_remove (set, color); if (set->len == 0) { g_ptr_array_unref (set); g_hash_table_remove (self->color_names, name); } return ret; }
static void access_point_removed_proxy (DBusGProxy *proxy, char *path, gpointer user_data) { NMDeviceWifi *self = NM_DEVICE_WIFI (user_data); NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (self); NMAccessPoint *ap; g_return_if_fail (self != NULL); ap = nm_device_wifi_get_access_point_by_path (self, path); if (ap) { if (ap == priv->active_ap) { g_object_unref (priv->active_ap); priv->active_ap = NULL; priv->null_active_ap = FALSE; _nm_object_queue_notify (NM_OBJECT (self), NM_DEVICE_WIFI_ACTIVE_ACCESS_POINT); priv->rate = 0; _nm_object_queue_notify (NM_OBJECT (self), NM_DEVICE_WIFI_BITRATE); } g_signal_emit (self, signals[ACCESS_POINT_REMOVED], 0, ap); g_ptr_array_remove (priv->aps, ap); g_object_unref (G_OBJECT (ap)); } }
static void clean_up_aps (NMDeviceWifi *self, gboolean notify) { NMDeviceWifiPrivate *priv; g_return_if_fail (NM_IS_DEVICE_WIFI (self)); priv = NM_DEVICE_WIFI_GET_PRIVATE (self); if (priv->active_ap) { g_object_unref (priv->active_ap); priv->active_ap = NULL; } if (priv->aps) { while (priv->aps->len) { NMAccessPoint *ap = NM_ACCESS_POINT (g_ptr_array_index (priv->aps, 0)); if (notify) g_signal_emit (self, signals[ACCESS_POINT_REMOVED], 0, ap); g_ptr_array_remove (priv->aps, ap); g_object_unref (ap); } g_ptr_array_free (priv->aps, TRUE); priv->aps = NULL; } }
static void pt_destroy (gpointer data, gboolean resident, gpointer user_data) { /* g_printerr ("%d: destroy 1 VsgVector3d (%p)\n", rk, data); */ g_ptr_array_remove (points, data); g_free (data); }
static void clean_up_nsps (NMDeviceWimax *self, gboolean notify) { NMDeviceWimaxPrivate *priv; g_return_if_fail (NM_IS_DEVICE_WIMAX (self)); priv = NM_DEVICE_WIMAX_GET_PRIVATE (self); if (priv->active_nsp) { g_object_unref (priv->active_nsp); priv->active_nsp = NULL; } if (priv->nsps) { while (priv->nsps->len) { NMWimaxNsp *nsp = NM_WIMAX_NSP (g_ptr_array_index (priv->nsps, 0)); if (notify) g_signal_emit (self, signals[NSP_REMOVED], 0, nsp); g_ptr_array_remove (priv->nsps, nsp); g_object_unref (nsp); } g_ptr_array_free (priv->nsps, TRUE); priv->nsps = NULL; } }
static gboolean on_close_button_clicked(GtkWidget* widget, GdkEvent* event, gpointer data) { meta_verbose("%s\n", __func__); DeepinWorkspaceOverview* self = (DeepinWorkspaceOverview*)data; DeepinWorkspaceOverviewPrivate* priv = self->priv; if (!priv->ready) return FALSE; MetaWindow* meta_window = meta_deepin_cloned_widget_get_window(priv->hovered_clone); for (int i = 0; i < priv->monitors->len; i++) { MonitorData* md = (MonitorData*)g_ptr_array_index(priv->monitors, i); if (!md->clones) continue; for (gint i = 0; i < md->clones->len; i++) { MetaDeepinClonedWidget* clone = g_ptr_array_index(md->clones, i); if (clone == priv->hovered_clone) { g_ptr_array_remove(md->clones, clone); gtk_container_remove(GTK_CONTAINER(self), clone); meta_window_delete(meta_window, CurrentTime); priv->hovered_clone = NULL; _hide_close_button(self); g_idle_add((GSourceFunc)on_idle, self); return TRUE; } } } return TRUE; }
static void on_window_removed(DeepinMessageHub* hub, MetaWindow* window, gpointer data) { DeepinWorkspaceOverview* self = DEEPIN_WORKSPACE_OVERVIEW(data); DeepinWorkspaceOverviewPrivate* priv = self->priv; for (int i = 0; i < priv->monitors->len; i++) { MonitorData* md = (MonitorData*)g_ptr_array_index(priv->monitors, i); if (!md->clones) continue; for (gint i = 0; i < md->clones->len; i++) { MetaDeepinClonedWidget* clone = g_ptr_array_index(md->clones, i); if (meta_deepin_cloned_widget_get_window(clone) == window) { g_ptr_array_remove(md->clones, clone); gtk_container_remove(GTK_CONTAINER(self), (GtkWidget*)clone); meta_verbose("%s remove clone for %s\n", __func__, window->desc); if (priv->hovered_clone == clone) { priv->hovered_clone = NULL; _hide_close_button(self); } if (priv->ready) g_idle_add((GSourceFunc)on_idle, self); return; } } } }
void pt_destroy (gpointer data, gboolean resident, gpointer array) { if (resident) g_ptr_array_remove ((GPtrArray *) array, data); g_free (data); }
int lcm_unsubscribe (lcm_t *lcm, lcm_subscription_t *h) { g_static_rec_mutex_lock (&lcm->mutex); // remove the handler from the master list int foundit = g_ptr_array_remove(lcm->handlers_all, h); if (lcm->provider && lcm->vtable->unsubscribe) { lcm->vtable->unsubscribe(lcm->provider, h->channel); } if (foundit) { // remove the handler from all the lists in the hash table g_hash_table_foreach(lcm->handlers_map, map_remove_handler_callback, h); if (!h->callback_scheduled) lcm_handler_free (h); else h->marked_for_deletion = 1; } g_static_rec_mutex_unlock (&lcm->mutex); return foundit ? 0 : -1; }
int PreloadChannelDtor(struct ChannelDesc *channel, int n) { int code = 0; int handle; assert(channel != NULL); assert(n < channel->source->len); /* adjust the size of writable channels */ handle = GPOINTER_TO_INT(CH_HANDLE(channel, n)); if(channel->limits[PutSizeLimit] && channel->limits[PutsLimit] && CH_PROTO(channel, n) == ProtoRegular) code = ftruncate(handle, channel->size); ZLOGS(LOG_DEBUG, "%s closed with getsize = %ld, putsize = %ld", channel->alias, channel->counters[GetSizeLimit], channel->counters[PutSizeLimit]); if(handle != 0) { if(CH_PROTO(channel, n) == ProtoRegular) close(handle); else fclose(CH_HANDLE(channel, n)); } g_ptr_array_remove(channel->source, CH_FILE(channel, n)); return -(code != 0); }
static void mnp_clock_tile_removed (MnpClockTile *tile, MnpClockArea *area) { g_ptr_array_remove (area->priv->clock_tiles, tile); area->priv->zone_remove_func (area, mnp_clock_tile_get_location(tile)->display, area->priv->zone_remove_data); }
static void on_content_removed_cb (TpProxy *proxy, const gchar *content_path, gpointer user_data, GObject *weak_object) { TpyCallChannel *self = TPY_CALL_CHANNEL (proxy); TpyCallContent *content = NULL, *c; guint i; DEBUG ("Content removed: %s", content_path); for (i = 0; i < self->priv->contents->len; i++) { c = g_ptr_array_index (self->priv->contents, i); if (g_strcmp0 (tp_proxy_get_object_path (c), content_path) == 0) { content = c; break; } } if (content != NULL) { g_signal_emit (self, _signals[CONTENT_REMOVED], 0, content); g_ptr_array_remove (self->priv->contents, content); } else { g_warning ("The removed content '%s' isn't in the call!", content_path); } }
static void update_failures (EmpathyWebcredentialsMonitor *self) { GVariant *failures, *f; GVariantIter iter; GList *new_list = NULL; guint i; failures = g_dbus_proxy_get_cached_property (self->priv->proxy, FAILURES_PROP); if (failures == NULL) { g_debug ("Does not implement Failures property"); return; } g_variant_iter_init (&iter, failures); while ((f = g_variant_iter_next_value (&iter)) != NULL) { guint32 id; AgAccount *account; id = g_variant_get_uint32 (f); account = ag_manager_get_account (self->priv->manager, id); if (account == NULL) continue; /* Pass ownership of 'account' to the list */ new_list = g_list_append (new_list, account); if (!tp_g_ptr_array_contains (self->priv->failures, account)) { g_ptr_array_add (self->priv->failures, g_object_ref (account)); g_signal_emit (self, signals[SIG_FAILURE_ADDED], 0, account); } g_variant_unref (f); } g_variant_unref (failures); for (i = 0; i < self->priv->failures->len; i++) { AgAccount *account = g_ptr_array_index (self->priv->failures, i); if (g_list_find (new_list, account) == NULL) { g_object_ref (account); g_ptr_array_remove (self->priv->failures, account); g_signal_emit (self, signals[SIG_FAILURE_REMOVED], 0, account); g_object_unref (account); } } g_list_free_full (new_list, g_object_unref); }
void pt_destroy (Pt *data, gboolean resident, gpointer user_data) { if (resident) g_ptr_array_remove (points, data); g_free (data); }
static void rg_destroy (gpointer data, gboolean resident, gpointer user_data) { /* g_printerr ("%d: destroy 1 Sphere (%p)\n", rk, data); */ g_ptr_array_remove (regions, data); g_free (data); }
static void remmina_widget_pool_on_widget_destroy(GtkWidget *widget, gpointer data) { g_ptr_array_remove(remmina_widget_pool, widget); if (remmina_widget_pool->len == 0 && remmina_widget_pool_try_quit_handler == 0) { /* Wait for a while to make sure no more windows will open before we quit the application */ remmina_widget_pool_try_quit_handler = g_timeout_add(10000, remmina_widget_pool_try_quit, NULL); } }
static void _recipients_button_remove_clicked(void *data, Evas_Object *obj, void *event_info) { (void) obj; (void) event_info; struct _recipient_pack *pack = (struct _recipient_pack *)data; g_ptr_array_remove(pack->view->recipients, pack->recipient); elm_object_item_del(pack->glit); }
gboolean af_animator_remove_transition (guint id, AfTransition *transition) { AfAnimator *animator; g_return_val_if_fail (animators != NULL, FALSE); g_return_val_if_fail (transition != NULL, FALSE); animator = g_hash_table_lookup (animators, GUINT_TO_POINTER (id)); g_return_val_if_fail (animator != NULL, FALSE); if (g_ptr_array_remove (animator->transitions, transition) == FALSE) return g_ptr_array_remove (animator->finished_transitions, transition); return TRUE; }
static void roomlist_channel_closed_cb (KindlingRoomlistChannel *channel, gpointer user_data) { KindlingRoomlistManager *self = KINDLING_ROOMLIST_MANAGER(user_data); KindlingRoomlistManagerPrivate *priv = KINDLING_ROOMLIST_MANAGER_GET_PRIVATE(self); tp_channel_manager_emit_channel_closed_for_object (self, TP_EXPORTABLE_CHANNEL(channel)); if (priv->channels != NULL) { g_ptr_array_remove (priv->channels, channel); g_object_unref (channel); } }