void events_destroy (vmi_instance_t vmi)
{
if(!(vmi->init_mode & VMI_INIT_EVENTS)){
return;
}
g_hash_table_foreach_steal(vmi->mem_events, event_entry_free, vmi);
g_hash_table_foreach_steal(vmi->reg_events, event_entry_free, vmi);
g_hash_table_foreach_remove(vmi->ss_events, event_entry_free, vmi);
g_hash_table_destroy(vmi->mem_events);
g_hash_table_destroy(vmi->reg_events);
g_hash_table_destroy(vmi->ss_events);
}
static int remove_unused(struct mwServiceAware *srvc) {
/* - create a GList of all the unused aware entries
- remove each unused aware from the service
- if the service is alive, send a removal message for the collected
unused.
*/
int ret = 0;
GList *dead = NULL, *l;
if(srvc->entries) {
g_info("bring out your dead *clang*");
g_hash_table_foreach_steal(srvc->entries, collect_dead, &dead);
}
if(dead) {
if(MW_SERVICE_IS_LIVE(srvc))
ret = send_rem(srvc->channel, dead) || ret;
for(l = dead; l; l = l->next)
aware_entry_free(l->data);
g_list_free(dead);
}
return ret;
}
static void
gst_file_index_dispose (GObject * object)
{
GstFileIndex *index = GST_FILE_INDEX (object);
if (index->location) {
g_free (index->location);
index->location = NULL;
}
{
GSList *elem;
for (elem = index->unresolved; elem; elem = g_slist_next (elem))
_file_index_id_free (elem->data, index->is_loaded);
g_slist_free (index->unresolved);
index->unresolved = NULL;
}
g_hash_table_foreach_steal (index->id_index,
(GHRFunc) _id_index_free_helper, index);
g_hash_table_destroy (index->id_index);
index->id_index = NULL;
gst_index_entry_free (index->ret_entry); /* hack */
G_OBJECT_CLASS (gst_file_index_parent_class)->dispose (object);
}
gboolean dbus_glib_object1_dict_send_method_impl(DBusGlibObject1 *self,
GHashTable* in_hash,
gint* out_int,
GError **error)
{
g_hash_table_foreach_steal(in_hash, iter_func, NULL);
*out_int = 5050;
return TRUE;
}
static void
_on_group_service_dispose (
gpointer data,
GObject *dead)
{
GumdDbusServerP2P *server = GUMD_DBUS_SERVER_P2P (data);
g_return_if_fail (server);
g_hash_table_foreach_steal (server->priv->group_service_adapters,
_compare_by_pointer, dead);
}
void clean_all_users_from_online(int fd)
{
int i;
for (i = 0; i < MAX_ONLINE_NUM; ++i) {
if (all_fds[i] && (all_fds[i]->fd == fd)) {
all_fds[i] = NULL;
g_hash_table_foreach_steal(all_home,clean_online_users, &i);
break;
}
}
}
void rofi_theme_widget_add_properties ( ThemeWidget *widget, GHashTable *table )
{
if ( table == NULL ) {
return;
}
if ( widget->properties == NULL ) {
widget->properties = table;
return;
}
g_hash_table_foreach_steal ( table, rofi_theme_steal_property_int, widget->properties );
g_hash_table_destroy ( table );
}
static gboolean clean_online_users(void* key, void* value, void* data)
{
home_t* h = value;
clean_user_args_t arg = {*(uint32_t*)data, h};
g_hash_table_foreach_steal(h->sprites, clean_user, &arg);
if (0 == g_hash_table_size(h->sprites)) {
free_homemaps(NULL, h, NULL);
return TRUE;
}
return FALSE;
}
gboolean
jaw_util_dispatch_key_event (AtkKeyEventStruct *event)
{
gint consumed = 0;
if (key_listener_list) {
GHashTable *new_hash = g_hash_table_new(NULL, NULL);
g_hash_table_foreach(key_listener_list, insert_hf, new_hash);
consumed = g_hash_table_foreach_steal(new_hash, notify_hf, event);
g_hash_table_destroy(new_hash);
}
return (consumed > 0) ? TRUE : FALSE;
}
static int remove_unused_attrib(struct mwServiceAware *srvc) {
GList *dead = NULL;
if(srvc->attribs) {
g_info("collecting dead attributes");
g_hash_table_foreach_steal(srvc->attribs, collect_attrib_dead, &dead);
}
/* since we stole them, we'll have to clean 'em up manually */
for(; dead; dead = g_list_delete_link(dead, dead)) {
attrib_entry_free(dead->data);
}
return MW_SERVICE_IS_LIVE(srvc)? send_attrib_list(srvc): 0;
}
static void
xfce_xsettings_helper_load (XfceXSettingsHelper *helper)
{
GHashTable *props;
props = xfconf_channel_get_properties (helper->channel, NULL);
if (G_LIKELY (props != NULL))
{
/* steal properties and put them in the settings table */
g_hash_table_foreach_steal (props,
(GHRFunc) xfce_xsettings_helper_prop_load, helper);
/* destroy the remaining properties */
g_hash_table_destroy (props);
}
}
static gint
mai_key_snooper(GtkWidget *the_widget, GdkEventKey *event, gpointer func_data)
{
/* notify each AtkKeySnoopFunc in turn... */
MaiKeyEventInfo *info = g_new0(MaiKeyEventInfo, 1);
gint consumed = 0;
if (key_listener_list) {
GHashTable *new_hash = g_hash_table_new(NULL, NULL);
g_hash_table_foreach (key_listener_list, insert_hf, new_hash);
info->key_event = atk_key_event_from_gdk_event_key (event);
info->func_data = func_data;
consumed = g_hash_table_foreach_steal (new_hash, notify_hf, info);
g_hash_table_destroy (new_hash);
g_free(info->key_event);
}
g_free(info);
return (consumed ? 1 : 0);
}
static void
anjuta_test_shell_remove_widget (AnjutaShell *shell,
GtkWidget *w,
GError **error)
{
// gint old_size;
GtkWidget *client_win;
AnjutaTestShell *window = ANJUTA_TEST_SHELL (shell);
g_return_if_fail (w != NULL);
// old_size = g_hash_table_size (window->widgets);
// g_object_set_data (G_OBJECT (w), "__temp_shell__", shell);
g_hash_table_foreach_steal (window->widgets, remove_from_widgets_hash, w);
// if (old_size != g_hash_table_size (window->widgets))
// {
client_win = gtk_widget_get_toplevel (w);
gtk_container_remove (GTK_CONTAINER (client_win), w);
gtk_widget_destroy (client_win);
//}
}
static void on_open_files( GtkAction* action, FindFile* data )
{
GtkTreeModel* model;
GtkTreeSelection* sel;
GtkTreeIter it;
GList *row, *rows, *sel_files;
GHashTable* hash;
GtkWidget* w;
VFSFileInfo* fi;
gboolean open_files_has_dir = FALSE; //sfm
PtkFileBrowser* file_browser = NULL; //sfm
gboolean open_files = TRUE;
if ( action )
open_files = (0 == strcmp( gtk_action_get_name(action), "OpenAction") );
sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( data->result_view ) );
rows = gtk_tree_selection_get_selected_rows( sel, &model );
if( ! rows )
return;
//sfm this frees list when new value inserted - caused segfault
//hash = g_hash_table_new_full( g_str_hash, g_str_equal, (GDestroyNotify)g_free, open_files ? (GDestroyNotify)vfs_file_info_list_free : NULL );
hash = g_hash_table_new_full( g_str_hash, g_str_equal, (GDestroyNotify)g_free, NULL );
for( row = rows; row; row = row->next )
{
char* dir;
GtkTreePath* tp = (GtkTreePath*)row->data;
if( gtk_tree_model_get_iter( model, &it, tp ) )
{
if( open_files ) /* open files */
gtk_tree_model_get( model, &it, COL_INFO, &fi, COL_DIR, &dir, -1 );
else /* open containing folders */
gtk_tree_model_get( model, &it, COL_DIR, &dir, -1 );
if( open_files )
{
GList *l;
l = g_hash_table_lookup( hash, dir );
l = g_list_prepend( l, vfs_file_info_ref(fi) );
g_hash_table_insert( hash, dir, l ); //sfm caused segfault with destroy function
if ( vfs_file_info_is_dir( fi ) ) //sfm
open_files_has_dir = TRUE;
}
else
{
if( g_hash_table_lookup( hash, dir ) )
g_free( dir );
g_hash_table_insert( hash, dir, NULL );
}
}
gtk_tree_path_free( tp );
}
g_list_free( rows );
if( open_files )
{
if ( open_files_has_dir )
{
w = GTK_WIDGET( fm_main_window_get_last_active() );
if( ! w )
{
w = fm_main_window_new();
gtk_window_set_default_size( GTK_WINDOW( w ), app_settings.width, app_settings.height );
}
gtk_window_present( (GtkWindow*)w );
file_browser = (PtkFileBrowser*)fm_main_window_get_current_file_browser(
(FMMainWindow*)w );
}
g_hash_table_foreach_steal( hash, (GHRFunc)open_file, file_browser );
}
else
{
w = GTK_WIDGET( fm_main_window_get_last_active() );
if( ! w )
{
w = fm_main_window_new();
gtk_window_set_default_size( GTK_WINDOW( w ), app_settings.width, app_settings.height );
}
g_hash_table_foreach( hash, (GHFunc)open_dir, w );
gtk_window_present( (GtkWindow*)w );
}
g_hash_table_destroy( hash );
}
gboolean
_gtk_source_language_file_parse_version2 (GtkSourceLanguage *language,
GtkSourceContextData *ctx_data)
{
GHashTable *defined_regexes, *styles;
gboolean success;
GError *error = NULL;
gchar *filename;
GHashTable *loaded_lang_ids;
GQueue *replacements;
g_return_val_if_fail (ctx_data != NULL, FALSE);
filename = language->priv->lang_file_name;
/* TODO: as an optimization tell the parser to merge CDATA
* as text nodes (XML_PARSE_NOCDATA), and to ignore blank
* nodes (XML_PARSE_NOBLANKS), if it is possible with
* xmlTextReader. */
xmlKeepBlanksDefault (0);
xmlLineNumbersDefault (1);
xmlSubstituteEntitiesDefault (1);
DEBUG (xmlPedanticParserDefault (1));
defined_regexes = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, g_free);
styles = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
(GDestroyNotify) _gtk_source_style_info_free);
loaded_lang_ids = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify) xmlFree,
NULL);
replacements = g_queue_new ();
success = file_parse (filename, language, ctx_data,
defined_regexes, styles,
loaded_lang_ids, replacements,
&error);
if (success)
success = _gtk_source_context_data_finish_parse (ctx_data, replacements->head, &error);
if (success)
g_hash_table_foreach_steal (styles,
(GHRFunc) steal_styles_mapping,
language->priv->styles);
g_queue_foreach (replacements, (GFunc) _gtk_source_context_replace_free, NULL);
g_queue_free (replacements);
g_hash_table_destroy (loaded_lang_ids);
g_hash_table_destroy (defined_regexes);
g_hash_table_destroy (styles);
if (!success)
{
g_warning ("Failed to load '%s': %s",
filename, error->message);
g_error_free (error);
return FALSE;
}
return TRUE;
}
void clean_home_by_idx(int idx)
{
g_hash_table_foreach(maps, do_clean_home_by_idx, &idx);
KDEBUG_LOG(0, "HOME USER CNT [%d %u]", idx, g_hash_table_size(maps));
g_hash_table_foreach_steal(war_sprites, noti_cli_leave_war, NULL);
}
