static void purple_protocol_finalize(GObject *object) { PurpleProtocol *protocol = PURPLE_PROTOCOL(object); GList *accounts, *l; accounts = purple_accounts_get_all_active(); for (l = accounts; l != NULL; l = l->next) { PurpleAccount *account = PURPLE_ACCOUNT(l->data); if (purple_account_is_disconnected(account)) continue; if (purple_strequal(protocol->id, purple_account_get_protocol_id(account))) purple_account_disconnect(account); } g_list_free(accounts); purple_request_close_with_handle(protocol); purple_notify_close_with_handle(protocol); purple_signals_disconnect_by_handle(protocol); purple_signals_unregister_by_instance(protocol); purple_prefs_disconnect_by_handle(protocol); user_splits_free(protocol); account_options_free(protocol); icon_spec_free(protocol); PURPLE_DBUS_UNREGISTER_POINTER(protocol); parent_class->finalize(object); }
void pidgin_connection_uninit(void) { purple_signals_disconnect_by_handle(pidgin_connection_get_handle()); g_hash_table_destroy(auto_reconns); }
static void finch_sound_uninit(void) { #ifdef USE_GSTREAMER if (!gst_init_failed) gst_deinit(); #endif purple_signals_disconnect_by_handle(finch_sound_get_handle()); }
void purple_xfers_uninit(void) { void *handle = purple_xfers_get_handle(); purple_signals_disconnect_by_handle(handle); purple_signals_unregister_by_instance(handle); g_hash_table_destroy(xfers_data); xfers_data = NULL; }
void purple_buddy_icons_uninit() { purple_signals_disconnect_by_handle(purple_buddy_icons_get_handle()); g_hash_table_destroy(account_cache); g_hash_table_destroy(icon_data_cache); g_hash_table_destroy(icon_file_cache); g_hash_table_destroy(pointer_icon_cache); g_free(old_icons_dir); g_free(cache_dir); }
void purple_plugins_uninit(void) { void *handle = purple_plugins_get_handle(); purple_signals_disconnect_by_handle(handle); purple_signals_unregister_by_instance(handle); while (search_paths) { g_free(search_paths->data); search_paths = g_list_delete_link(search_paths, search_paths); } }
void finch_pounces_manager_hide(void) { if (pounces_manager == NULL) return; if (pounces_manager->window != NULL) gnt_widget_destroy(pounces_manager->window); purple_signals_disconnect_by_handle(pounces_manager); g_free(pounces_manager); pounces_manager = NULL; }
static gboolean indicator_unload(PurplePlugin *plugin) { indicator_docklet_uninit(plugin); purple_signals_disconnect_by_handle(plugin->handle); if (plugin->extra) { g_object_unref(G_OBJECT(plugin->extra)); plugin->extra = NULL; } pidgin_blist_visibility_manager_remove(); return TRUE; }
void purple_pounces_uninit() { if (save_timer != 0) { purple_timeout_remove(save_timer); save_timer = 0; sync_pounces(); } purple_signals_disconnect_by_handle(purple_pounces_get_handle()); g_hash_table_destroy(pounce_handlers); pounce_handlers = NULL; }
void twitter_conv_icon_account_unload(PurpleAccount * account) { PurpleConnection *gc = purple_account_get_connection(account); TwitterConnectionData *twitter; GList *l; /* Remove icons from all conversations */ for (l = purple_get_chats(); l; l = l->next) { if (purple_conversation_get_account(l->data) == account) twitter_conv_icon_remove_conversation_conv_icons(l->data); } if (gc && (twitter = gc->proto_data)) { if (twitter->icons) { purple_signals_disconnect_by_handle(twitter->icons); g_hash_table_destroy(twitter->icons); } twitter->icons = NULL; } }
static gboolean plugin_unload(PurplePlugin *plugin) { // disconnect callbacks purple_signals_disconnect_by_handle(plugin); return TRUE; }
/* XXX: There's no such thing in pidgin. Perhaps there should be? */ void finch_pounces_uninit() { purple_pounces_unregister_handler(FINCH_UI); purple_signals_disconnect_by_handle(finch_pounces_get_handle()); }
void purple_idle_uninit() { purple_signals_disconnect_by_handle(purple_idle_get_handle()); }
gboolean purple_plugin_unload(PurplePlugin *plugin) { #ifdef PURPLE_PLUGINS GList *l; GList *ll; g_return_val_if_fail(plugin != NULL, FALSE); g_return_val_if_fail(purple_plugin_is_loaded(plugin), FALSE); purple_debug_info("plugins", "Unloading plugin %s\n", plugin->info->name); /* Unload all plugins that depend on this plugin. */ for (l = plugin->dependent_plugins; l != NULL; l = ll) { const char * dep_name = (const char *)l->data; PurplePlugin *dep_plugin; /* Store a pointer to the next element in the list. * This is because we'll be modifying this list in the loop. */ ll = l->next; dep_plugin = purple_plugins_find_with_id(dep_name); if (dep_plugin != NULL && purple_plugin_is_loaded(dep_plugin)) { if (!purple_plugin_unload(dep_plugin)) { g_free(plugin->error); plugin->error = g_strdup_printf(_("%s requires %s, but it failed to unload."), _(plugin->info->name), _(dep_plugin->info->name)); return FALSE; } else { #if 0 /* This isn't necessary. This has already been done when unloading dep_plugin. */ plugin->dependent_plugins = g_list_delete_link(plugin->dependent_plugins, l); #endif } } } /* Remove this plugin from each dependency's dependent_plugins list. */ for (l = plugin->info->dependencies; l != NULL; l = l->next) { const char *dep_name = (const char *)l->data; PurplePlugin *dependency; dependency = purple_plugins_find_with_id(dep_name); if (dependency != NULL) dependency->dependent_plugins = g_list_remove(dependency->dependent_plugins, plugin->info->id); else purple_debug_error("plugins", "Unable to remove from dependency list for %s\n", dep_name); } if (plugin->native_plugin) { if (plugin->info->unload && !plugin->info->unload(plugin)) return FALSE; if (plugin->info->type == PURPLE_PLUGIN_PROTOCOL) { PurplePluginProtocolInfo *prpl_info; GList *l; prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin); for (l = prpl_info->user_splits; l != NULL; l = l->next) purple_account_user_split_destroy(l->data); for (l = prpl_info->protocol_options; l != NULL; l = l->next) purple_account_option_destroy(l->data); if (prpl_info->user_splits != NULL) { g_list_free(prpl_info->user_splits); prpl_info->user_splits = NULL; } if (prpl_info->protocol_options != NULL) { g_list_free(prpl_info->protocol_options); prpl_info->protocol_options = NULL; } } } else { PurplePlugin *loader; PurplePluginLoaderInfo *loader_info; loader = find_loader_for_plugin(plugin); if (loader == NULL) return FALSE; loader_info = PURPLE_PLUGIN_LOADER_INFO(loader); if (loader_info->unload && !loader_info->unload(plugin)) return FALSE; } /* cancel any pending dialogs the plugin has */ purple_request_close_with_handle(plugin); purple_notify_close_with_handle(plugin); purple_signals_disconnect_by_handle(plugin); purple_plugin_ipc_unregister_all(plugin); loaded_plugins = g_list_remove(loaded_plugins, plugin); if ((plugin->info != NULL) && PURPLE_IS_PROTOCOL_PLUGIN(plugin)) protocol_plugins = g_list_remove(protocol_plugins, plugin); plugins_to_disable = g_list_remove(plugins_to_disable, plugin); plugin->loaded = FALSE; /* We wouldn't be anywhere near here if the plugin wasn't loaded, so * if plugin->error is set at all, it had to be from a previous * unload failure. It's obviously okay now. */ g_free(plugin->error); plugin->error = NULL; purple_signal_emit(purple_plugins_get_handle(), "plugin-unload", plugin); purple_prefs_disconnect_by_handle(plugin); return TRUE; #else return TRUE; #endif /* PURPLE_PLUGINS */ }