static void kms_base_hub_finalize (GObject * object) { KmsBaseHub *self = KMS_BASE_HUB (object); GST_DEBUG_OBJECT (self, "finalize"); g_rec_mutex_clear (&self->priv->mutex); if (self->priv->ports != NULL) { g_hash_table_unref (self->priv->ports); self->priv->ports = NULL; } G_OBJECT_CLASS (kms_base_hub_parent_class)->finalize (object); }
void empathy_import_account_data_free (EmpathyImportAccountData *data) { if (data == NULL) return; if (data->protocol != NULL) g_free (data->protocol); if (data->connection_manager != NULL) g_free (data->connection_manager); if (data->settings != NULL) g_hash_table_unref (data->settings); if (data->source != NULL) g_free (data->source); g_slice_free (EmpathyImportAccountData, data); }
static void git_log_pane_finalize (GObject *object) { GitLogPane *self; self = GIT_LOG_PANE (object); g_object_unref (self->priv->builder); g_free (self->priv->path); g_hash_table_destroy (self->priv->branches_table); g_hash_table_unref (self->priv->refs); g_free (self->priv->selected_branch); g_free (self->priv); G_OBJECT_CLASS (git_log_pane_parent_class)->finalize (object); }
static void entangle_pixbuf_loader_finalize(GObject *object) { EntanglePixbufLoader *loader = ENTANGLE_PIXBUF_LOADER(object); EntanglePixbufLoaderPrivate *priv = loader->priv; ENTANGLE_DEBUG("Finalize pixbuf loader %p", object); g_thread_pool_free(priv->workers, TRUE, TRUE); if (priv->colourTransform) g_object_unref(priv->colourTransform); g_hash_table_unref(priv->pixbufs); g_mutex_free(priv->lock); G_OBJECT_CLASS(entangle_pixbuf_loader_parent_class)->finalize(object); }
static void set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { NMSettingBondPrivate *priv = NM_SETTING_BOND_GET_PRIVATE (object); switch (prop_id) { case PROP_OPTIONS: g_hash_table_unref (priv->options); priv->options = _nm_utils_copy_strdict (g_value_get_boxed (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_validate_ssim_finalize (GObject * object) { GstValidateSsim *self = GST_VALIDATE_SSIM (object); void (*chain_up) (GObject *) = ((GObjectClass *) gst_validate_ssim_parent_class)->finalize; g_list_free_full (self->priv->converters, (GDestroyNotify) ssim_convert_info_free); if (self->priv->outconverter_info.converter) gst_video_converter_free (self->priv->outconverter_info.converter); g_hash_table_unref (self->priv->ref_frames_cache); chain_up (object); }
static void git_ref_command_finalize (GObject *object) { GitRefCommand *self; self = GIT_REF_COMMAND (object); g_regex_unref (self->priv->branch_ref_regex); g_regex_unref (self->priv->tag_ref_regex); g_regex_unref (self->priv->remote_ref_regex); g_hash_table_unref (self->priv->refs); g_free (self->priv); G_OBJECT_CLASS (git_ref_command_parent_class)->finalize (object); }
void gi_source_scanner_free (GISourceScanner *scanner) { g_object_unref (scanner->current_file); g_hash_table_destroy (scanner->typedef_table); g_slist_foreach (scanner->comments, (GFunc)gi_source_comment_free, NULL); g_slist_free (scanner->comments); g_slist_foreach (scanner->symbols, (GFunc)gi_source_symbol_unref, NULL); g_slist_free (scanner->symbols); g_hash_table_unref (scanner->files); g_queue_clear (&scanner->conditionals); }
static void egg_file_format_filter_info_free (gpointer boxed) { EggFileFormatFilterInfo *self; if (boxed) { self = boxed; g_hash_table_unref (self->extension_set); g_slist_foreach (self->extension_list, (GFunc) g_free, NULL); g_slist_free (self->extension_list); g_free (self->name); g_free (self); } }
static void korva_upnp_host_data_dispose (GObject *object) { KorvaUPnPHostData *self = KORVA_UPNP_HOST_DATA (object); korva_upnp_host_data_cancel_timeout (self); g_clear_object (&(self->priv->file)); if (self->priv->meta_data != NULL) { g_hash_table_unref (self->priv->meta_data); self->priv->meta_data = NULL; } G_OBJECT_CLASS (korva_upnp_host_data_parent_class)->dispose (object); }
static Computer * computer_get_info(void) { Computer *computer; computer = g_new0(Computer, 1); if (moreinfo) { #ifdef g_hash_table_unref g_hash_table_unref(moreinfo); #else g_free(moreinfo); #endif } moreinfo = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); shell_status_update("Getting processor information..."); computer->processor = computer_get_processor(); shell_status_update("Getting memory information..."); computer->memory = computer_get_memory(); shell_status_update("Getting operating system information..."); computer->os = computer_get_os(); shell_status_update("Getting display information..."); computer->display = computer_get_display(); shell_status_update("Getting sound card information..."); computer->alsa = computer_get_alsainfo(); shell_status_update("Getting mounted file system information..."); scan_filesystems(); shell_status_update("Getting shared directories..."); scan_shared_directories(); shell_status_update("Reading sensors..."); read_sensors(); shell_status_update("Obtaining network information..."); scan_net_interfaces(); computer->date_time = "..."; return computer; }
static gboolean load_assertions (GkmXdgTrust *self, GNode *asn) { GHashTable *assertions; GkmAssertion *assertion; GBytes *key; GNode *node; guint count, i; g_assert (self); g_assert (asn); assertions = self->pv->assertions; self->pv->assertions = create_assertions (); count = egg_asn1x_count (egg_asn1x_node (asn, "assertions", NULL)); for (i = 0; i < count; ++i) { node = egg_asn1x_node (asn, "assertions", i + 1, NULL); g_return_val_if_fail (node != NULL, FALSE); /* We use the raw DER encoding as an assertion */ key = egg_asn1x_get_element_raw (node); g_return_val_if_fail (key != NULL, FALSE); /* Already have this assertion? */ assertion = g_hash_table_lookup (assertions, key); if (assertion) { if (!g_hash_table_steal (assertions, key)) g_assert_not_reached (); /* Create a new assertion */ } else { assertion = create_assertion (self, node); } add_assertion_to_trust (self, assertion, NULL); g_bytes_unref (key); g_object_unref (assertion); } /* Override the stored assertions and netscape trust */ g_hash_table_remove_all (assertions); g_hash_table_unref (assertions); return TRUE; }
static void import_widget_add_account (EmpathyImportWidget *self, EmpathyImportAccountData *data) { TpAccountManager *account_manager; gchar *display_name = NULL; GHashTable *properties; GValue *username; account_manager = tp_account_manager_dup (); DEBUG ("connection_manager: %s\n", data->connection_manager); /* Set the display name of the account */ username = g_hash_table_lookup (data->settings, "account"); if (!tp_strdiff (data->protocol, "irc")) { const gchar *server; server = tp_asv_get_string (data->settings, "server"); if (server != NULL) display_name = g_strdup_printf ("%s on %s", g_value_get_string (username), server); } if (display_name == NULL) { display_name = g_strdup_printf ("%s (%s)", data->protocol, g_value_get_string (username)); } DEBUG ("display name: %s\n", display_name); properties = tp_asv_new (NULL, NULL); tp_asv_set_boolean (properties, TP_IFACE_ACCOUNT ".Enabled", data->enabled); tp_account_manager_create_account_async (account_manager, (const gchar*) data->connection_manager, data->protocol, display_name, data->settings, properties, import_widget_create_account_cb, g_object_ref (self)); g_hash_table_unref (properties); g_free (display_name); g_object_unref (account_manager); }
static void populate_regions (GtkBuilder *builder, const gchar *current_lang) { gchar *current_region; GSettings *locale_settings; GHashTable *ht; GHashTableIter htiter; GtkTreeModel *model; gchar *name, *language; GtkWidget *treeview; GtkTreeIter iter; GtkTreeSelection *selection; treeview = GTK_WIDGET (gtk_builder_get_object (builder, "region_selector")); /* don't update the setting just because the list is repopulated */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_handlers_block_by_func (selection, update_settings_cb, builder); model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)); locale_settings = g_object_get_data (G_OBJECT (treeview), "settings"); ht = cc_common_language_get_initial_regions (current_lang); current_region = g_settings_get_string (locale_settings, "region"); if (!current_region || !current_region[0]) { current_region = g_strdup (current_lang); } else if (!g_hash_table_lookup (ht, current_region)) { name = gdm_get_region_from_name (current_region, NULL); g_hash_table_insert (ht, g_strdup (current_region), name); } gtk_list_store_clear (GTK_LIST_STORE (model)); g_hash_table_iter_init (&htiter, ht); while (g_hash_table_iter_next (&htiter, (gpointer *)&name, (gpointer *)&language)) { gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, name, 1, language, -1); } g_hash_table_unref (ht); select_region (GTK_TREE_VIEW (treeview), current_region); g_free (current_region); g_signal_handlers_unblock_by_func (selection, update_settings_cb, builder); }
static void gst_rtsp_media_factory_finalize (GObject * obj) { GstRTSPMediaFactory *factory = GST_RTSP_MEDIA_FACTORY (obj); GstRTSPMediaFactoryPrivate *priv = factory->priv; if (priv->permissions) gst_rtsp_permissions_unref (priv->permissions); g_hash_table_unref (priv->medias); g_mutex_clear (&priv->medias_lock); g_free (priv->launch); g_mutex_clear (&priv->lock); if (priv->pool) g_object_unref (priv->pool); G_OBJECT_CLASS (gst_rtsp_media_factory_parent_class)->finalize (obj); }
static void g_dbus_object_manager_server_finalize (GObject *object) { GDBusObjectManagerServer *manager = G_DBUS_OBJECT_MANAGER_SERVER (object); if (manager->priv->connection != NULL) { unexport_all (manager, TRUE); g_object_unref (manager->priv->connection); } g_hash_table_unref (manager->priv->map_object_path_to_data); g_free (manager->priv->object_path); g_free (manager->priv->object_path_ending_in_slash); if (G_OBJECT_CLASS (g_dbus_object_manager_server_parent_class)->finalize != NULL) G_OBJECT_CLASS (g_dbus_object_manager_server_parent_class)->finalize (object); }
/* SUBSCRIBE */ static void _eventd_protocol_evp_parse_subscribe(EventdProtocol *self, const gchar * const *argv, GError **error) { if ( argv == NULL ) eventd_protocol_call_subscribe((EventdProtocol *) self, NULL); else { GHashTable *subscriptions; subscriptions = g_hash_table_new(g_str_hash, g_str_equal); g_hash_table_add(subscriptions, (gpointer) argv[0]); eventd_protocol_call_subscribe((EventdProtocol *) self, subscriptions); g_hash_table_unref(subscriptions); } self->base_state = EVENTD_PROTOCOL_EVP_STATE_SUBSCRIBE; self->state = self->base_state; }
/* Removes non-responsive resources */ static gboolean refresh_cache (gpointer data) { GSSDPResourceBrowser *resource_browser; GSSDPResourceBrowserPrivate *priv; resource_browser = GSSDP_RESOURCE_BROWSER (data); priv = gssdp_resource_browser_get_instance_private (resource_browser); g_hash_table_foreach_remove (priv->resources, refresh_cache_helper, priv->fresh_resources); g_hash_table_unref (priv->fresh_resources); priv->fresh_resources = NULL; priv->refresh_cache_src = NULL; return FALSE; }
void _gdk_x11_xsettings_finish (GdkX11Screen *x11_screen) { gdk_window_remove_filter (gdk_screen_get_root_window (GDK_SCREEN (x11_screen)), gdk_xsettings_root_window_filter, x11_screen); if (x11_screen->xsettings_manager_window) { gdk_window_remove_filter (x11_screen->xsettings_manager_window, gdk_xsettings_manager_window_filter, x11_screen); g_object_unref (x11_screen->xsettings_manager_window); x11_screen->xsettings_manager_window = NULL; } if (x11_screen->xsettings) { g_hash_table_unref (x11_screen->xsettings); x11_screen->xsettings = NULL; } }
void g_uri_unref (GUri *uri) { g_return_if_fail(uri); g_return_if_fail(uri->ref_count > 0); if (g_atomic_int_dec_and_test(&uri->ref_count)) { g_free(uri->fragment); g_free(uri->hostname); g_free(uri->password); g_free(uri->path); g_free(uri->scheme); g_free(uri->username); g_hash_table_unref(uri->params); g_slice_free(GUri, uri); } }
static void miner_manager_finalize (GObject *object) { TrackerMinerManagerPrivate *priv; priv = TRACKER_MINER_MANAGER_GET_PRIVATE (object); if (priv->connection) { g_object_unref (priv->connection); } g_list_foreach (priv->miners, (GFunc) miner_data_free, NULL); g_list_free (priv->miners); g_hash_table_unref (priv->miner_proxies); G_OBJECT_CLASS (tracker_miner_manager_parent_class)->finalize (object); }
void ccnet_peer_finalize (GObject *object) { CcnetPeer *peer = CCNET_PEER (object); g_free (peer->name); g_free (peer->addr_str); g_free (peer->service_url); g_hash_table_unref (peer->processors); g_free (peer->session_key); evbuffer_free (peer->packet); if (peer->pubkey) RSA_free (peer->pubkey); G_OBJECT_CLASS(ccnet_peer_parent_class)->finalize (object); }
static void gst_gl_effects_reset_resources (GstGLFilter * filter) { GstGLEffects *effects = GST_GL_EFFECTS (filter); // g_message ("reset resources"); //release shaders in the gl thread g_hash_table_foreach (effects->shaderstable, gst_gl_effects_ghash_func_clean, filter); //clean the htable without calling values destructors //because shaders have been released in the glthread //through the foreach func g_hash_table_unref (effects->shaderstable); effects->shaderstable = NULL; }
static void mtn_connman_dispose (GObject *object) { MtnConnman *connman; connman = MTN_CONNMAN (object); if (connman->priv->properties) { g_hash_table_unref (connman->priv->properties); connman->priv->properties = NULL; } if (connman->priv->services) g_variant_unref (connman->priv->services); G_OBJECT_CLASS (mtn_connman_parent_class)->dispose (object); }
static void kms_dispatcher_dispose (GObject * object) { KmsDispatcher *self = KMS_DISPATCHER (object); GST_DEBUG_OBJECT (self, "dispose"); KMS_DISPATCHER_LOCK (self); if (self->priv->ports != NULL) { g_hash_table_remove_all (self->priv->ports); g_hash_table_unref (self->priv->ports); self->priv->ports = NULL; } KMS_DISPATCHER_UNLOCK (self); G_OBJECT_CLASS (kms_dispatcher_parent_class)->dispose (object); }
static void photos_selection_toolbar_dispose (GObject *object) { PhotosSelectionToolbar *self = PHOTOS_SELECTION_TOOLBAR (object); PhotosSelectionToolbarPrivate *priv = self->priv; if (priv->item_listeners != NULL) { g_hash_table_unref (priv->item_listeners); priv->item_listeners = NULL; } g_clear_object (&priv->item_mngr); g_clear_object (&priv->sel_cntrlr); G_OBJECT_CLASS (photos_selection_toolbar_parent_class)->dispose (object); }
static void _eventd_evp_bye(gpointer data, LibeventdEvpContext *evp) { EventdEvpClient *client = data; EventdPluginContext *context = client->context; #ifdef DEBUG g_debug("Client connection closed"); #endif /* DEBUG */ libeventd_evp_context_free(client->evp); g_hash_table_unref(client->events); context->clients = g_slist_remove(context->clients, client); g_free(client); }
void kms_sdp_message_context_destroy (SdpMessageContext * ctx) { if (ctx->msg != NULL) { gst_sdp_message_free (ctx->msg); } g_hash_table_unref (ctx->mids); g_slist_free_full (ctx->medias, (GDestroyNotify) kms_sdp_context_destroy_media_config); g_slist_free_full (ctx->groups, (GDestroyNotify) kms_sdp_context_destroy_media_group); g_slice_free (SdpMessageContext, ctx); }
/* * Parse the ISO-639 code list if available on this system, and fill * @base_lang_list with English names of all needed base codes. * * It will also fill the static @all_lang_list. */ static gboolean parse_iso_codes (GHashTable *base_lang_list, GError **error) { gboolean success = TRUE; #ifdef HAVE_ISO_CODES static const GMarkupParser markup_parser = { iso_codes_parser_start_element, iso_codes_parser_end_element, NULL, /* characters */ NULL, /* passthrough */ NULL /* error */ }; GimpXmlParser *xml_parser; gchar *filename; IsoCodesParser parser = { 0, }; g_return_val_if_fail (error == NULL || *error == NULL, FALSE); iso_codes_parser_init (); parser.base_lang_list = g_hash_table_ref (base_lang_list); xml_parser = gimp_xml_parser_new (&markup_parser, &parser); #ifdef G_OS_WIN32 filename = g_build_filename (gimp_data_directory (), "..", "..", "xml", "iso-codes", "iso_639.xml", NULL); #else filename = g_build_filename (ISO_CODES_LOCATION, "iso_639.xml", NULL); #endif success = gimp_xml_parser_parse_file (xml_parser, filename, error); g_free (filename); gimp_xml_parser_free (xml_parser); g_hash_table_unref (parser.base_lang_list); #endif return success; }
static void chat_conversations_list_dispose (GObject *object) { ChatConversationsList *self = CHAT_CONVERSATIONS_LIST (object); ChatConversationsListPrivate *priv = self->priv; if (priv->accounts != NULL) { g_hash_table_unref (priv->accounts); priv->accounts = NULL; } g_clear_object (&priv->am); g_clear_object (&priv->lm); G_OBJECT_CLASS (chat_conversations_list_parent_class)->dispose (object); }